1. Packages
  2. Commercetools Provider
  3. API Docs
  4. Store
commercetools 1.19.2 published on Friday, Mar 7, 2025 by labd

commercetools.Store

Explore with Pulumi AI

Stores can be used to model, for example, physical retail locations, brand stores, or country-specific stores.

See also the Stores API Documentation

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as commercetools from "@pulumi/commercetools";

const us_supply_channel = new commercetools.Channel("us-supply-channel", {
    key: "US-SUP",
    roles: ["InventorySupply"],
    name: {
        "en-US": "Supply channel",
    },
    description: {
        "en-US": "Supply channel desc",
    },
});
const us_dist_channel = new commercetools.Channel("us-dist-channel", {
    key: "US-DIST",
    roles: ["ProductDistribution"],
    name: {
        "en-US": "Dist channel",
    },
    description: {
        "en-US": "Dist channel desc",
    },
});
const my_store_type = new commercetools.Type("my-store-type", {
    key: "my-custom-store-type",
    name: {
        en: "My Store Type",
    },
    description: {
        en: "A custom store type",
    },
    resourceTypeIds: ["store"],
    fields: [{
        name: "some-field",
        label: {
            en: "Some Field",
        },
        type: {
            name: "String",
        },
    }],
});
const my_store = new commercetools.Store("my-store", {
    key: "my-store",
    name: {
        "en-US": "My store",
    },
    countries: [
        "NL",
        "BE",
    ],
    languages: ["en-US"],
    distributionChannels: ["US-DIST"],
    supplyChannels: ["US-SUP"],
    custom: {
        typeId: my_store_type.typeId,
        fields: {
            "my-field": "ja",
        },
    },
}, {
    dependsOn: [
        us_supply_channel,
        us_dist_channel,
    ],
});
Copy
import pulumi
import pulumi_commercetools as commercetools

us_supply_channel = commercetools.Channel("us-supply-channel",
    key="US-SUP",
    roles=["InventorySupply"],
    name={
        "en-US": "Supply channel",
    },
    description={
        "en-US": "Supply channel desc",
    })
us_dist_channel = commercetools.Channel("us-dist-channel",
    key="US-DIST",
    roles=["ProductDistribution"],
    name={
        "en-US": "Dist channel",
    },
    description={
        "en-US": "Dist channel desc",
    })
my_store_type = commercetools.Type("my-store-type",
    key="my-custom-store-type",
    name={
        "en": "My Store Type",
    },
    description={
        "en": "A custom store type",
    },
    resource_type_ids=["store"],
    fields=[{
        "name": "some-field",
        "label": {
            "en": "Some Field",
        },
        "type": {
            "name": "String",
        },
    }])
my_store = commercetools.Store("my-store",
    key="my-store",
    name={
        "en-US": "My store",
    },
    countries=[
        "NL",
        "BE",
    ],
    languages=["en-US"],
    distribution_channels=["US-DIST"],
    supply_channels=["US-SUP"],
    custom={
        "type_id": my_store_type.type_id,
        "fields": {
            "my-field": "ja",
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[
            us_supply_channel,
            us_dist_channel,
        ]))
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/commercetools/commercetools"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := commercetools.NewChannel(ctx, "us-supply-channel", &commercetools.ChannelArgs{
			Key: pulumi.String("US-SUP"),
			Roles: pulumi.StringArray{
				pulumi.String("InventorySupply"),
			},
			Name: pulumi.StringMap{
				"en-US": pulumi.String("Supply channel"),
			},
			Description: pulumi.StringMap{
				"en-US": pulumi.String("Supply channel desc"),
			},
		})
		if err != nil {
			return err
		}
		_, err = commercetools.NewChannel(ctx, "us-dist-channel", &commercetools.ChannelArgs{
			Key: pulumi.String("US-DIST"),
			Roles: pulumi.StringArray{
				pulumi.String("ProductDistribution"),
			},
			Name: pulumi.StringMap{
				"en-US": pulumi.String("Dist channel"),
			},
			Description: pulumi.StringMap{
				"en-US": pulumi.String("Dist channel desc"),
			},
		})
		if err != nil {
			return err
		}
		_, err = commercetools.NewType(ctx, "my-store-type", &commercetools.TypeArgs{
			Key: pulumi.String("my-custom-store-type"),
			Name: pulumi.StringMap{
				"en": pulumi.String("My Store Type"),
			},
			Description: pulumi.StringMap{
				"en": pulumi.String("A custom store type"),
			},
			ResourceTypeIds: pulumi.StringArray{
				pulumi.String("store"),
			},
			Fields: commercetools.TypeFieldArray{
				&commercetools.TypeFieldArgs{
					Name: pulumi.String("some-field"),
					Label: pulumi.StringMap{
						"en": pulumi.String("Some Field"),
					},
					Type: &commercetools.TypeFieldTypeArgs{
						Name: pulumi.String("String"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = commercetools.NewStore(ctx, "my-store", &commercetools.StoreArgs{
			Key: pulumi.String("my-store"),
			Name: pulumi.StringMap{
				"en-US": pulumi.String("My store"),
			},
			Countries: pulumi.StringArray{
				pulumi.String("NL"),
				pulumi.String("BE"),
			},
			Languages: pulumi.StringArray{
				pulumi.String("en-US"),
			},
			DistributionChannels: pulumi.StringArray{
				pulumi.String("US-DIST"),
			},
			SupplyChannels: pulumi.StringArray{
				pulumi.String("US-SUP"),
			},
			Custom: &commercetools.StoreCustomArgs{
				TypeId: my_store_type.TypeId,
				Fields: pulumi.StringMap{
					"my-field": pulumi.String("ja"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			us_supply_channel,
			us_dist_channel,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Commercetools = Pulumi.Commercetools;

return await Deployment.RunAsync(() => 
{
    var us_supply_channel = new Commercetools.Channel("us-supply-channel", new()
    {
        Key = "US-SUP",
        Roles = new[]
        {
            "InventorySupply",
        },
        Name = 
        {
            { "en-US", "Supply channel" },
        },
        Description = 
        {
            { "en-US", "Supply channel desc" },
        },
    });

    var us_dist_channel = new Commercetools.Channel("us-dist-channel", new()
    {
        Key = "US-DIST",
        Roles = new[]
        {
            "ProductDistribution",
        },
        Name = 
        {
            { "en-US", "Dist channel" },
        },
        Description = 
        {
            { "en-US", "Dist channel desc" },
        },
    });

    var my_store_type = new Commercetools.Type("my-store-type", new()
    {
        Key = "my-custom-store-type",
        Name = 
        {
            { "en", "My Store Type" },
        },
        Description = 
        {
            { "en", "A custom store type" },
        },
        ResourceTypeIds = new[]
        {
            "store",
        },
        Fields = new[]
        {
            new Commercetools.Inputs.TypeFieldArgs
            {
                Name = "some-field",
                Label = 
                {
                    { "en", "Some Field" },
                },
                Type = new Commercetools.Inputs.TypeFieldTypeArgs
                {
                    Name = "String",
                },
            },
        },
    });

    var my_store = new Commercetools.Store("my-store", new()
    {
        Key = "my-store",
        Name = 
        {
            { "en-US", "My store" },
        },
        Countries = new[]
        {
            "NL",
            "BE",
        },
        Languages = new[]
        {
            "en-US",
        },
        DistributionChannels = new[]
        {
            "US-DIST",
        },
        SupplyChannels = new[]
        {
            "US-SUP",
        },
        Custom = new Commercetools.Inputs.StoreCustomArgs
        {
            TypeId = my_store_type.TypeId,
            Fields = 
            {
                { "my-field", "ja" },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            us_supply_channel,
            us_dist_channel,
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.commercetools.Channel;
import com.pulumi.commercetools.ChannelArgs;
import com.pulumi.commercetools.Type;
import com.pulumi.commercetools.TypeArgs;
import com.pulumi.commercetools.inputs.TypeFieldArgs;
import com.pulumi.commercetools.inputs.TypeFieldTypeArgs;
import com.pulumi.commercetools.Store;
import com.pulumi.commercetools.StoreArgs;
import com.pulumi.commercetools.inputs.StoreCustomArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var us_supply_channel = new Channel("us-supply-channel", ChannelArgs.builder()
            .key("US-SUP")
            .roles("InventorySupply")
            .name(Map.of("en-US", "Supply channel"))
            .description(Map.of("en-US", "Supply channel desc"))
            .build());

        var us_dist_channel = new Channel("us-dist-channel", ChannelArgs.builder()
            .key("US-DIST")
            .roles("ProductDistribution")
            .name(Map.of("en-US", "Dist channel"))
            .description(Map.of("en-US", "Dist channel desc"))
            .build());

        var my_store_type = new Type("my-store-type", TypeArgs.builder()
            .key("my-custom-store-type")
            .name(Map.of("en", "My Store Type"))
            .description(Map.of("en", "A custom store type"))
            .resourceTypeIds("store")
            .fields(TypeFieldArgs.builder()
                .name("some-field")
                .label(Map.of("en", "Some Field"))
                .type(TypeFieldTypeArgs.builder()
                    .name("String")
                    .build())
                .build())
            .build());

        var my_store = new Store("my-store", StoreArgs.builder()
            .key("my-store")
            .name(Map.of("en-US", "My store"))
            .countries(            
                "NL",
                "BE")
            .languages("en-US")
            .distributionChannels("US-DIST")
            .supplyChannels("US-SUP")
            .custom(StoreCustomArgs.builder()
                .typeId(my_store_type.typeId())
                .fields(Map.of("my-field", "ja"))
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    us_supply_channel,
                    us_dist_channel)
                .build());

    }
}
Copy
resources:
  us-supply-channel:
    type: commercetools:Channel
    properties:
      key: US-SUP
      roles:
        - InventorySupply
      name:
        en-US: Supply channel
      description:
        en-US: Supply channel desc
  us-dist-channel:
    type: commercetools:Channel
    properties:
      key: US-DIST
      roles:
        - ProductDistribution
      name:
        en-US: Dist channel
      description:
        en-US: Dist channel desc
  my-store-type:
    type: commercetools:Type
    properties:
      key: my-custom-store-type
      name:
        en: My Store Type
      description:
        en: A custom store type
      resourceTypeIds:
        - store
      fields:
        - name: some-field
          label:
            en: Some Field
          type:
            name: String
  my-store:
    type: commercetools:Store
    properties:
      key: my-store
      name:
        en-US: My store
      countries:
        - NL
        - BE
      languages:
        - en-US
      distributionChannels:
        - US-DIST
      supplyChannels:
        - US-SUP
      custom:
        typeId: ${["my-store-type"].typeId}
        fields:
          my-field: ja
    options:
      dependsOn:
        - ${["us-supply-channel"]}
        - ${["us-dist-channel"]}
Copy

Create Store Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new Store(name: string, args: StoreArgs, opts?: CustomResourceOptions);
@overload
def Store(resource_name: str,
          args: StoreArgs,
          opts: Optional[ResourceOptions] = None)

@overload
def Store(resource_name: str,
          opts: Optional[ResourceOptions] = None,
          key: Optional[str] = None,
          countries: Optional[Sequence[str]] = None,
          custom: Optional[StoreCustomArgs] = None,
          distribution_channels: Optional[Sequence[str]] = None,
          languages: Optional[Sequence[str]] = None,
          name: Optional[Mapping[str, str]] = None,
          product_selections: Optional[Sequence[StoreProductSelectionArgs]] = None,
          store_id: Optional[str] = None,
          supply_channels: Optional[Sequence[str]] = None)
func NewStore(ctx *Context, name string, args StoreArgs, opts ...ResourceOption) (*Store, error)
public Store(string name, StoreArgs args, CustomResourceOptions? opts = null)
public Store(String name, StoreArgs args)
public Store(String name, StoreArgs args, CustomResourceOptions options)
type: commercetools:Store
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. StoreArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. StoreArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. StoreArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. StoreArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. StoreArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var storeResource = new Commercetools.Store("storeResource", new()
{
    Key = "string",
    Countries = new[]
    {
        "string",
    },
    Custom = new Commercetools.Inputs.StoreCustomArgs
    {
        TypeId = "string",
        Fields = 
        {
            { "string", "string" },
        },
    },
    DistributionChannels = new[]
    {
        "string",
    },
    Languages = new[]
    {
        "string",
    },
    Name = 
    {
        { "string", "string" },
    },
    ProductSelections = new[]
    {
        new Commercetools.Inputs.StoreProductSelectionArgs
        {
            Active = false,
            ProductSelectionId = "string",
        },
    },
    StoreId = "string",
    SupplyChannels = new[]
    {
        "string",
    },
});
Copy
example, err := commercetools.NewStore(ctx, "storeResource", &commercetools.StoreArgs{
Key: pulumi.String("string"),
Countries: pulumi.StringArray{
pulumi.String("string"),
},
Custom: &.StoreCustomArgs{
TypeId: pulumi.String("string"),
Fields: pulumi.StringMap{
"string": pulumi.String("string"),
},
},
DistributionChannels: pulumi.StringArray{
pulumi.String("string"),
},
Languages: pulumi.StringArray{
pulumi.String("string"),
},
Name: pulumi.StringMap{
"string": pulumi.String("string"),
},
ProductSelections: .StoreProductSelectionArray{
&.StoreProductSelectionArgs{
Active: pulumi.Bool(false),
ProductSelectionId: pulumi.String("string"),
},
},
StoreId: pulumi.String("string"),
SupplyChannels: pulumi.StringArray{
pulumi.String("string"),
},
})
Copy
var storeResource = new Store("storeResource", StoreArgs.builder()
    .key("string")
    .countries("string")
    .custom(StoreCustomArgs.builder()
        .typeId("string")
        .fields(Map.of("string", "string"))
        .build())
    .distributionChannels("string")
    .languages("string")
    .name(Map.of("string", "string"))
    .productSelections(StoreProductSelectionArgs.builder()
        .active(false)
        .productSelectionId("string")
        .build())
    .storeId("string")
    .supplyChannels("string")
    .build());
Copy
store_resource = commercetools.Store("storeResource",
    key="string",
    countries=["string"],
    custom={
        "type_id": "string",
        "fields": {
            "string": "string",
        },
    },
    distribution_channels=["string"],
    languages=["string"],
    name={
        "string": "string",
    },
    product_selections=[{
        "active": False,
        "product_selection_id": "string",
    }],
    store_id="string",
    supply_channels=["string"])
Copy
const storeResource = new commercetools.Store("storeResource", {
    key: "string",
    countries: ["string"],
    custom: {
        typeId: "string",
        fields: {
            string: "string",
        },
    },
    distributionChannels: ["string"],
    languages: ["string"],
    name: {
        string: "string",
    },
    productSelections: [{
        active: false,
        productSelectionId: "string",
    }],
    storeId: "string",
    supplyChannels: ["string"],
});
Copy
type: commercetools:Store
properties:
    countries:
        - string
    custom:
        fields:
            string: string
        typeId: string
    distributionChannels:
        - string
    key: string
    languages:
        - string
    name:
        string: string
    productSelections:
        - active: false
          productSelectionId: string
    storeId: string
    supplyChannels:
        - string
Copy

Store Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The Store resource accepts the following input properties:

Key This property is required. string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
Countries List<string>
A two-digit country code as per ISO 3166-1 alpha-2
Custom StoreCustom
DistributionChannels List<string>
Set of ResourceIdentifier to a Channel with ProductDistribution
Languages List<string>
IETF Language Tag
Name Dictionary<string, string>
LocalizedString
ProductSelections List<StoreProductSelection>
Controls availability of Products for this Store via Product Selections
StoreId string
The ID of this resource.
SupplyChannels List<string>
Set of ResourceIdentifier of Channels with InventorySupply
Key This property is required. string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
Countries []string
A two-digit country code as per ISO 3166-1 alpha-2
Custom StoreCustomArgs
DistributionChannels []string
Set of ResourceIdentifier to a Channel with ProductDistribution
Languages []string
IETF Language Tag
Name map[string]string
LocalizedString
ProductSelections []StoreProductSelectionArgs
Controls availability of Products for this Store via Product Selections
StoreId string
The ID of this resource.
SupplyChannels []string
Set of ResourceIdentifier of Channels with InventorySupply
key This property is required. String
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
countries List<String>
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustom
distributionChannels List<String>
Set of ResourceIdentifier to a Channel with ProductDistribution
languages List<String>
IETF Language Tag
name Map<String,String>
LocalizedString
productSelections List<StoreProductSelection>
Controls availability of Products for this Store via Product Selections
storeId String
The ID of this resource.
supplyChannels List<String>
Set of ResourceIdentifier of Channels with InventorySupply
key This property is required. string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
countries string[]
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustom
distributionChannels string[]
Set of ResourceIdentifier to a Channel with ProductDistribution
languages string[]
IETF Language Tag
name {[key: string]: string}
LocalizedString
productSelections StoreProductSelection[]
Controls availability of Products for this Store via Product Selections
storeId string
The ID of this resource.
supplyChannels string[]
Set of ResourceIdentifier of Channels with InventorySupply
key This property is required. str
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
countries Sequence[str]
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustomArgs
distribution_channels Sequence[str]
Set of ResourceIdentifier to a Channel with ProductDistribution
languages Sequence[str]
IETF Language Tag
name Mapping[str, str]
LocalizedString
product_selections Sequence[StoreProductSelectionArgs]
Controls availability of Products for this Store via Product Selections
store_id str
The ID of this resource.
supply_channels Sequence[str]
Set of ResourceIdentifier of Channels with InventorySupply
key This property is required. String
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
countries List<String>
A two-digit country code as per ISO 3166-1 alpha-2
custom Property Map
distributionChannels List<String>
Set of ResourceIdentifier to a Channel with ProductDistribution
languages List<String>
IETF Language Tag
name Map<String>
LocalizedString
productSelections List<Property Map>
Controls availability of Products for this Store via Product Selections
storeId String
The ID of this resource.
supplyChannels List<String>
Set of ResourceIdentifier of Channels with InventorySupply

Outputs

All input properties are implicitly available as output properties. Additionally, the Store resource produces the following output properties:

Id string
The provider-assigned unique ID for this managed resource.
Version double
Id string
The provider-assigned unique ID for this managed resource.
Version float64
id String
The provider-assigned unique ID for this managed resource.
version Double
id string
The provider-assigned unique ID for this managed resource.
version number
id str
The provider-assigned unique ID for this managed resource.
version float
id String
The provider-assigned unique ID for this managed resource.
version Number

Look up Existing Store Resource

Get an existing Store resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: StoreState, opts?: CustomResourceOptions): Store
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        countries: Optional[Sequence[str]] = None,
        custom: Optional[StoreCustomArgs] = None,
        distribution_channels: Optional[Sequence[str]] = None,
        key: Optional[str] = None,
        languages: Optional[Sequence[str]] = None,
        name: Optional[Mapping[str, str]] = None,
        product_selections: Optional[Sequence[StoreProductSelectionArgs]] = None,
        store_id: Optional[str] = None,
        supply_channels: Optional[Sequence[str]] = None,
        version: Optional[float] = None) -> Store
func GetStore(ctx *Context, name string, id IDInput, state *StoreState, opts ...ResourceOption) (*Store, error)
public static Store Get(string name, Input<string> id, StoreState? state, CustomResourceOptions? opts = null)
public static Store get(String name, Output<String> id, StoreState state, CustomResourceOptions options)
resources:  _:    type: commercetools:Store    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:
Countries List<string>
A two-digit country code as per ISO 3166-1 alpha-2
Custom StoreCustom
DistributionChannels List<string>
Set of ResourceIdentifier to a Channel with ProductDistribution
Key string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
Languages List<string>
IETF Language Tag
Name Dictionary<string, string>
LocalizedString
ProductSelections List<StoreProductSelection>
Controls availability of Products for this Store via Product Selections
StoreId string
The ID of this resource.
SupplyChannels List<string>
Set of ResourceIdentifier of Channels with InventorySupply
Version double
Countries []string
A two-digit country code as per ISO 3166-1 alpha-2
Custom StoreCustomArgs
DistributionChannels []string
Set of ResourceIdentifier to a Channel with ProductDistribution
Key string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
Languages []string
IETF Language Tag
Name map[string]string
LocalizedString
ProductSelections []StoreProductSelectionArgs
Controls availability of Products for this Store via Product Selections
StoreId string
The ID of this resource.
SupplyChannels []string
Set of ResourceIdentifier of Channels with InventorySupply
Version float64
countries List<String>
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustom
distributionChannels List<String>
Set of ResourceIdentifier to a Channel with ProductDistribution
key String
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
languages List<String>
IETF Language Tag
name Map<String,String>
LocalizedString
productSelections List<StoreProductSelection>
Controls availability of Products for this Store via Product Selections
storeId String
The ID of this resource.
supplyChannels List<String>
Set of ResourceIdentifier of Channels with InventorySupply
version Double
countries string[]
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustom
distributionChannels string[]
Set of ResourceIdentifier to a Channel with ProductDistribution
key string
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
languages string[]
IETF Language Tag
name {[key: string]: string}
LocalizedString
productSelections StoreProductSelection[]
Controls availability of Products for this Store via Product Selections
storeId string
The ID of this resource.
supplyChannels string[]
Set of ResourceIdentifier of Channels with InventorySupply
version number
countries Sequence[str]
A two-digit country code as per ISO 3166-1 alpha-2
custom StoreCustomArgs
distribution_channels Sequence[str]
Set of ResourceIdentifier to a Channel with ProductDistribution
key str
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
languages Sequence[str]
IETF Language Tag
name Mapping[str, str]
LocalizedString
product_selections Sequence[StoreProductSelectionArgs]
Controls availability of Products for this Store via Product Selections
store_id str
The ID of this resource.
supply_channels Sequence[str]
Set of ResourceIdentifier of Channels with InventorySupply
version float
countries List<String>
A two-digit country code as per ISO 3166-1 alpha-2
custom Property Map
distributionChannels List<String>
Set of ResourceIdentifier to a Channel with ProductDistribution
key String
User-specific unique identifier for the store. The key is mandatory and immutable. It is used to reference the store
languages List<String>
IETF Language Tag
name Map<String>
LocalizedString
productSelections List<Property Map>
Controls availability of Products for this Store via Product Selections
storeId String
The ID of this resource.
supplyChannels List<String>
Set of ResourceIdentifier of Channels with InventorySupply
version Number

Supporting Types

StoreCustom
, StoreCustomArgs

TypeId This property is required. string
Fields Dictionary<string, string>
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})
TypeId This property is required. string
Fields map[string]string
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})
typeId This property is required. String
fields Map<String,String>
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})
typeId This property is required. string
fields {[key: string]: string}
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})
type_id This property is required. str
fields Mapping[str, str]
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})
typeId This property is required. String
fields Map<String>
Custom fields for this resource. Note that the values need to be provided as JSON encoded strings: my-value = jsonencode({"key": "value"})

StoreProductSelection
, StoreProductSelectionArgs

Active This property is required. bool
If true, all Products assigned to this Product Selection are part of the Store's assortment
ProductSelectionId This property is required. string
Resource Identifier of a ProductSelection
Active This property is required. bool
If true, all Products assigned to this Product Selection are part of the Store's assortment
ProductSelectionId This property is required. string
Resource Identifier of a ProductSelection
active This property is required. Boolean
If true, all Products assigned to this Product Selection are part of the Store's assortment
productSelectionId This property is required. String
Resource Identifier of a ProductSelection
active This property is required. boolean
If true, all Products assigned to this Product Selection are part of the Store's assortment
productSelectionId This property is required. string
Resource Identifier of a ProductSelection
active This property is required. bool
If true, all Products assigned to this Product Selection are part of the Store's assortment
product_selection_id This property is required. str
Resource Identifier of a ProductSelection
active This property is required. Boolean
If true, all Products assigned to this Product Selection are part of the Store's assortment
productSelectionId This property is required. String
Resource Identifier of a ProductSelection

Package Details

Repository
commercetools labd/terraform-provider-commercetools
License
Notes
This Pulumi package is based on the commercetools Terraform Provider.