1. Packages
  2. Commercetools Provider
  3. API Docs
  4. Store
commercetools 1.21.1 published on Tuesday, Oct 7, 2025 by labd
labd/terraform-provider-commercetools

commercetools.Store

Get Started
commercetools logo
commercetools 1.21.1 published on Tuesday, Oct 7, 2025 by labd
labd/terraform-provider-commercetools

    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,
    ],
});

    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,
        ]))

    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 {
		us_supply_channel, 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
		}
		us_dist_channel, 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
		}
		my_store_type, 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
	})
}

    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,
        },
    });

});

    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());

    }
}

    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"]}

    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 string
    The unique name of the resource.
    args StoreArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args 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 string
    The unique name of the resource.
    args StoreArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args StoreArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args 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",
    },
});

    example, err := commercetools.NewStore(ctx, "storeResource", &commercetools.StoreArgs{
	Key: pulumi.String("string"),
	Countries: pulumi.StringArray{
		pulumi.String("string"),
	},
	Custom: &commercetools.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: commercetools.StoreProductSelectionArray{
		&commercetools.StoreProductSelectionArgs{
			Active:             pulumi.Bool(false),
			ProductSelectionId: pulumi.String("string"),
		},
	},
	StoreId: pulumi.String("string"),
	SupplyChannels: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    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());

    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"])

    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"],
});

    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

    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 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 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 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 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 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 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
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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 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 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 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 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 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 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 bool
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    ProductSelectionId string
    Resource Identifier of a ProductSelection
    Active bool
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    ProductSelectionId string
    Resource Identifier of a ProductSelection
    active Boolean
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    productSelectionId String
    Resource Identifier of a ProductSelection
    active boolean
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    productSelectionId string
    Resource Identifier of a ProductSelection
    active bool
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    product_selection_id str
    Resource Identifier of a ProductSelection
    active Boolean
    If true, all Products assigned to this Product Selection are part of the Store's assortment
    productSelectionId 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.
    commercetools logo
    commercetools 1.21.1 published on Tuesday, Oct 7, 2025 by labd
    labd/terraform-provider-commercetools
      Meet Neo: Your AI Platform Teammate