@commercetools-frontend/mc-scripts 21.7.0 → 21.9.0

package/dist/declarations/src/generated/core.d.ts

@@ -0,0 +1,710 @@
+export declare type Maybe<T> = T | null;
+export declare type InputMaybe<T> = Maybe<T>;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    /** [ISO 3166-1](http://en.wikipedia.org/wiki/ISO_3166-1) country code. */
+    Country: any;
+    /** Represents a currency. Currencies are identified by their [ISO 4217](http://www.iso.org/iso/home/standards/currency_codes.htm) currency codes. */
+    Currency: any;
+    /** DateTime is a scalar value that represents an ISO8601 formatted date and time. */
+    DateTime: any;
+    /** DateTimeZone is a scalar value that represents a time zone. */
+    DateTimeZone: any;
+    /** Locale is a scalar value represented as a string language tag. */
+    Locale: any;
+    /** The `Long` scalar type represents non-fractional signed whole numeric values. Long can represent values between -(2^63) and 2^63 - 1. */
+    Long: any;
+};
+export declare type TAddTeam = {
+    members?: InputMaybe<Array<TReferenceInput>>;
+    name: Scalars['String'];
+    permissions?: InputMaybe<Scalars['String']>;
+};
+export declare type TAddTeamMembership = {
+    teamId: Scalars['String'];
+    user: TReferenceInput;
+};
+export declare enum TBusinessRole {
+    /** Business Dev, Sales & Account Management role. */
+    BusinessDevSalesAndAccountManagement = "BusinessDevSalesAndAccountManagement",
+    /** Business Intelligence role. */
+    BusinessIntelligence = "BusinessIntelligence",
+    /** Buying, Planning & Inventory Management role. */
+    BuyingPlanningAndInventoryManagement = "BuyingPlanningAndInventoryManagement",
+    /** Customer Service role. */
+    CustomerService = "CustomerService",
+    /** Data Quality & Content Management role. */
+    DataQualityAndContentManagement = "DataQualityAndContentManagement",
+    /** Executive Management role. */
+    ExecutiveManagement = "ExecutiveManagement",
+    /** Finance & Accounting role. */
+    FinanceAndAccounting = "FinanceAndAccounting",
+    /** Fulfillment & Operations Management role. */
+    FulfillmentAndOperationsManagement = "FulfillmentAndOperationsManagement",
+    /** Legal & People role. */
+    LegalAndPeople = "LegalAndPeople",
+    /** Logistics & Supply Chain role. */
+    LogisticsAndSupplyChain = "LogisticsAndSupplyChain",
+    /** Marketing role. */
+    Marketing = "Marketing",
+    /** Offline Retail Store role. */
+    OfflineRetailStore = "OfflineRetailStore",
+    /** Operations, IT & Support Engineering role. */
+    OperationsItAndSupportEngineering = "OperationsITAndSupportEngineering",
+    /** Other role. */
+    Other = "Other",
+    /** Software Development & Solutions Architect role. */
+    SoftwareDevelopmentAndSolutionsArchitect = "SoftwareDevelopmentAndSolutionsArchitect",
+    /** Product Management (Tech) role. */
+    TechProductManagement = "TechProductManagement",
+    /** Project & Program Management (Tech) role. */
+    TechProjectAndProgramManagement = "TechProjectAndProgramManagement",
+    /** UX/UI Design role. */
+    UxuiDesign = "UXUIDesign"
+}
+export declare type TCartClassificationType = TShippingRateInputType & {
+    __typename?: 'CartClassificationType';
+    type: Scalars['String'];
+    values: Array<TShippingRateInputLocalizedEnumValue>;
+};
+export declare type TCartDiscountLimits = {
+    __typename?: 'CartDiscountLimits';
+    withoutDiscountCodeLimit?: Maybe<Scalars['Long']>;
+};
+export declare type TCartLimits = {
+    __typename?: 'CartLimits';
+    maxCarts?: Maybe<Scalars['Long']>;
+};
+export declare type TCartScoreType = TShippingRateInputType & {
+    __typename?: 'CartScoreType';
+    type: Scalars['String'];
+};
+export declare type TCartValueType = TShippingRateInputType & {
+    __typename?: 'CartValueType';
+    type: Scalars['String'];
+};
+export declare type TCategoryLimits = {
+    __typename?: 'CategoryLimits';
+    maxTotalCategories?: Maybe<Scalars['Int']>;
+};
+export declare type TCdnContainerConfiguration = {
+    __typename?: 'CdnContainerConfiguration';
+    enabled: Scalars['Boolean'];
+};
+export declare type TChangeName = {
+    name: Scalars['String'];
+};
+export declare type TChangeTeamName = {
+    name: Scalars['String'];
+    teamId: Scalars['String'];
+};
+export declare type TClustersConfig = {
+    __typename?: 'ClustersConfig';
+    db?: Maybe<TDbClustersConfig>;
+    elasticsearch?: Maybe<TEsCluster>;
+};
+export declare type TClustersConfigInput = {
+    db?: InputMaybe<TDbClustersConfigInput>;
+    elasticsearch?: InputMaybe<TEsClusterInput>;
+};
+export declare type TCreateOrganizationCommand = {
+    defaultClusters?: InputMaybe<TClustersConfigInput>;
+    name: Scalars['String'];
+    owner: TReferenceInput;
+};
+export declare type TCreatePermissionCommand = {
+    actionRightPermissions?: InputMaybe<Array<Scalars['String']>>;
+    dataFences?: InputMaybe<Array<TDataFenceDraft>>;
+    group: Scalars['String'];
+    hiddenMenuItems?: InputMaybe<Array<Scalars['String']>>;
+    owner: TReferenceInput;
+    resourceAccessPermissions?: InputMaybe<Array<Scalars['String']>>;
+    team: TReferenceInput;
+};
+export declare type TCustomObjectLimits = {
+    __typename?: 'CustomObjectLimits';
+    maxCustomObjects?: Maybe<Scalars['Long']>;
+};
+export declare type TCustomerGroupLimits = {
+    __typename?: 'CustomerGroupLimits';
+    maxCustomerGroups?: Maybe<Scalars['Long']>;
+};
+export declare type TCustomerLimits = {
+    __typename?: 'CustomerLimits';
+    maxCustomers?: Maybe<Scalars['Long']>;
+};
+export declare type TDbClusterConfig = {
+    __typename?: 'DBClusterConfig';
+    dbClusterKey: TDbClusterKey;
+    sharded: Scalars['Boolean'];
+};
+export declare type TDbClusterConfigInput = {
+    dbClusterKey: TDbClusterKeyInput;
+    sharded: Scalars['Boolean'];
+};
+export declare type TDbClusterKey = {
+    __typename?: 'DBClusterKey';
+    name: Scalars['String'];
+};
+export declare type TDbClusterKeyInput = {
+    name: Scalars['String'];
+};
+export declare type TDbClustersConfig = {
+    __typename?: 'DBClustersConfig';
+    carts?: Maybe<TDbClusterConfig>;
+    commits?: Maybe<TDbClusterConfig>;
+    default: TDbClusterKey;
+    orders?: Maybe<TDbClusterConfig>;
+};
+export declare type TDbClustersConfigInput = {
+    carts?: InputMaybe<TDbClusterConfigInput>;
+    commits?: InputMaybe<TDbClusterConfigInput>;
+    default: TDbClusterKeyInput;
+    orders?: InputMaybe<TDbClusterConfigInput>;
+};
+export declare type TDataFence = {
+    type: Scalars['String'];
+};
+export declare type TDataFenceDraft = {
+    store: TDataFenceStoreDraftType;
+};
+export declare type TDataFenceStoreDraftType = {
+    storeKeys: Array<Scalars['String']>;
+};
+export declare type TEsAlternativeComparisonConfig = {
+    __typename?: 'ESAlternativeComparisonConfig';
+    comparisonProbability: Scalars['Float'];
+    logComparisonResults: Scalars['Boolean'];
+    versioning?: Maybe<Scalars['Boolean']>;
+};
+export declare type TEsAlternativeComparisonConfigInput = {
+    comparisonProbability: Scalars['Float'];
+    logComparisonResults: Scalars['Boolean'];
+    versioning?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type TEsCluster = {
+    __typename?: 'ESCluster';
+    categoriesShardConfig?: Maybe<TEsClusterShardConfig>;
+    categoryComparison?: Maybe<TEsAlternativeComparisonConfig>;
+    clusterKey: Scalars['String'];
+    productComparison?: Maybe<TEsAlternativeComparisonConfig>;
+    productsShardConfig?: Maybe<TEsClusterShardConfig>;
+    replicateToClusterKey?: Maybe<Scalars['String']>;
+};
+export declare type TEsClusterInput = {
+    categoriesShardConfig?: InputMaybe<TEsClusterShardConfigInput>;
+    categoryComparison?: InputMaybe<TEsAlternativeComparisonConfigInput>;
+    clusterKey: Scalars['String'];
+    productComparison?: InputMaybe<TEsAlternativeComparisonConfigInput>;
+    productsShardConfig?: InputMaybe<TEsClusterShardConfigInput>;
+    replicateToClusterKey?: InputMaybe<Scalars['String']>;
+};
+export declare type TEsClusterShardConfig = {
+    __typename?: 'ESClusterShardConfig';
+    numberOfReplicas?: Maybe<Scalars['Int']>;
+    numberOfShards?: Maybe<Scalars['Int']>;
+    refreshIntervalSeconds?: Maybe<Scalars['Int']>;
+    versioning?: Maybe<Scalars['Boolean']>;
+};
+export declare type TEsClusterShardConfigInput = {
+    numberOfReplicas?: InputMaybe<Scalars['Int']>;
+    numberOfShards?: InputMaybe<Scalars['Int']>;
+    refreshIntervalSeconds?: InputMaybe<Scalars['Int']>;
+    versioning?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type TExtensionLimits = {
+    __typename?: 'ExtensionLimits';
+    maxTimeoutInMs?: Maybe<Scalars['Int']>;
+};
+export declare type TExternalOAuthInput = {
+    authorizationHeader: Scalars['String'];
+    url: Scalars['String'];
+};
+export declare type TInitiator = {
+    __typename?: 'Initiator';
+    anonymousId?: Maybe<Scalars['String']>;
+    clientId?: Maybe<Scalars['String']>;
+    customerRef?: Maybe<TReference>;
+    externalUserId?: Maybe<Scalars['String']>;
+    isPlatformClient?: Maybe<Scalars['Boolean']>;
+    userRef?: Maybe<TReference>;
+};
+export declare type TLocalizedString = {
+    __typename?: 'LocalizedString';
+    locale: Scalars['Locale'];
+    value: Scalars['String'];
+};
+export declare type TMessagesConfiguration = {
+    __typename?: 'MessagesConfiguration';
+    deleteDaysAfterCreation?: Maybe<Scalars['Int']>;
+    enabled: Scalars['Boolean'];
+};
+export declare type TMutation = {
+    __typename?: 'Mutation';
+    createMyOrganization?: Maybe<TOrganization>;
+    createMyPermission?: Maybe<TPermission>;
+    createMyProject?: Maybe<TProject>;
+    createPermission?: Maybe<TPermission>;
+    deleteMyOrganization?: Maybe<TOrganization>;
+    deleteMyPermission?: Maybe<TPermission>;
+    deleteMyProject?: Maybe<TProject>;
+    deletePermission?: Maybe<TPermission>;
+    updateMyOrganization?: Maybe<TOrganization>;
+    updateMyPermission?: Maybe<TPermission>;
+    updatePermission?: Maybe<TPermission>;
+};
+export declare type TMutation_CreateMyOrganizationArgs = {
+    draft: TCreateOrganizationCommand;
+};
+export declare type TMutation_CreateMyPermissionArgs = {
+    draft: TCreatePermissionCommand;
+};
+export declare type TMutation_CreateMyProjectArgs = {
+    draft: TProjectDraftType;
+};
+export declare type TMutation_CreatePermissionArgs = {
+    draft: TCreatePermissionCommand;
+};
+export declare type TMutation_DeleteMyOrganizationArgs = {
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_DeleteMyPermissionArgs = {
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_DeleteMyProjectArgs = {
+    key: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_DeletePermissionArgs = {
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_UpdateMyOrganizationArgs = {
+    actions: Array<TOrganizationUpdateAction>;
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_UpdateMyPermissionArgs = {
+    actions: Array<TPermissionUpdateAction>;
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TMutation_UpdatePermissionArgs = {
+    actions: Array<TPermissionUpdateAction>;
+    id: Scalars['String'];
+    version: Scalars['Long'];
+};
+export declare type TOrderEditLimits = {
+    __typename?: 'OrderEditLimits';
+    maxOrderEdits?: Maybe<Scalars['Long']>;
+};
+export declare type TOrganization = TVersioned & {
+    __typename?: 'Organization';
+    createdAt: Scalars['DateTime'];
+    createdBy?: Maybe<TInitiator>;
+    defaultClusters?: Maybe<TClustersConfig>;
+    id: Scalars['String'];
+    lastModifiedAt: Scalars['DateTime'];
+    lastModifiedBy?: Maybe<TInitiator>;
+    name: Scalars['String'];
+    teams: Array<TTeam>;
+    version: Scalars['Long'];
+};
+export declare type TOrganizationQueryResult = {
+    __typename?: 'OrganizationQueryResult';
+    count: Scalars['Int'];
+    /** BETA: This feature can be subject to change and should be used carefully in production. https://docs.commercetools.com/api/contract#public-beta */
+    exists: Scalars['Boolean'];
+    offset: Scalars['Int'];
+    results: Array<TOrganization>;
+    total: Scalars['Long'];
+};
+export declare type TOrganizationUpdateAction = {
+    addTeam?: InputMaybe<TAddTeam>;
+    addTeamMembership?: InputMaybe<TAddTeamMembership>;
+    changeName?: InputMaybe<TChangeName>;
+    changeTeamName?: InputMaybe<TChangeTeamName>;
+    removeTeam?: InputMaybe<TRemoveTeam>;
+    removeTeamMembership?: InputMaybe<TRemoveTeamMembership>;
+};
+export declare type TPermission = TVersioned & {
+    __typename?: 'Permission';
+    actionRightPermissions: Array<Scalars['String']>;
+    createdAt: Scalars['DateTime'];
+    createdBy?: Maybe<TInitiator>;
+    dataFences: Array<TDataFence>;
+    group: Scalars['String'];
+    hiddenMenuItems: Array<Scalars['String']>;
+    id: Scalars['String'];
+    lastModifiedAt: Scalars['DateTime'];
+    lastModifiedBy?: Maybe<TInitiator>;
+    ownerRef: TReference;
+    resourceAccessPermissions: Array<Scalars['String']>;
+    teamRef: TReference;
+    version: Scalars['Long'];
+};
+export declare type TPermissionQueryResult = {
+    __typename?: 'PermissionQueryResult';
+    count: Scalars['Int'];
+    /** BETA: This feature can be subject to change and should be used carefully in production. https://docs.commercetools.com/api/contract#public-beta */
+    exists: Scalars['Boolean'];
+    offset: Scalars['Int'];
+    results: Array<TPermission>;
+    total: Scalars['Long'];
+};
+export declare type TPermissionUpdateAction = {
+    setActionRightPermissions?: InputMaybe<TSetPermissionActionRightPermissions>;
+    setDataFences?: InputMaybe<TSetPermissionDataFences>;
+    setHiddenMenuItems?: InputMaybe<TSetPermissionHiddenMenuItems>;
+    setResourceAccessPermissions?: InputMaybe<TSetPermissionResourceAccessPermissions>;
+};
+export declare type TProductDiscountLimits = {
+    __typename?: 'ProductDiscountLimits';
+    activeLimit?: Maybe<Scalars['Long']>;
+};
+export declare type TProductLimits = {
+    __typename?: 'ProductLimits';
+    pricesLimitPerVariant?: Maybe<Scalars['Int']>;
+    variantLimit?: Maybe<Scalars['Int']>;
+};
+export declare type TProductTypeLimits = {
+    __typename?: 'ProductTypeLimits';
+    maxTotalProductTypes?: Maybe<Scalars['Int']>;
+};
+export declare type TProject = TVersioned & {
+    __typename?: 'Project';
+    billingInfo?: Maybe<TProjectBillingInfo>;
+    cdnContainer?: Maybe<TPublicContainer>;
+    cdnContainerConfiguration: TCdnContainerConfiguration;
+    countries: Array<Scalars['Country']>;
+    createdAt: Scalars['DateTime'];
+    createdBy?: Maybe<TInitiator>;
+    currencies: Array<Scalars['Currency']>;
+    customLimits?: Maybe<TProjectCustomLimits>;
+    id: Scalars['String'];
+    initialized: Scalars['Boolean'];
+    isProductionProject?: Maybe<Scalars['Boolean']>;
+    key: Scalars['String'];
+    languages: Array<Scalars['Locale']>;
+    lastModifiedAt: Scalars['DateTime'];
+    lastModifiedBy?: Maybe<TInitiator>;
+    messages: TMessagesConfiguration;
+    name: Scalars['String'];
+    owner?: Maybe<TOrganization>;
+    ownerRef?: Maybe<TReference>;
+    participations: Array<TOrganization>;
+    participationsRef: Array<TReference>;
+    plan: Scalars['String'];
+    shippingRateInputType?: Maybe<TShippingRateInputType>;
+    suspended?: Maybe<TProjectSuspendData>;
+    trialUntil?: Maybe<Scalars['DateTime']>;
+    version: Scalars['Long'];
+};
+export declare type TProjectBillingInfo = {
+    __typename?: 'ProjectBillingInfo';
+    accountId?: Maybe<Scalars['String']>;
+    accountName?: Maybe<Scalars['String']>;
+    accountNumber?: Maybe<Scalars['String']>;
+    comment?: Maybe<Scalars['String']>;
+    contractNumber?: Maybe<Scalars['String']>;
+};
+export declare type TProjectCustomLimits = {
+    __typename?: 'ProjectCustomLimits';
+    cartDiscounts?: Maybe<TCartDiscountLimits>;
+    carts?: Maybe<TCartLimits>;
+    categoryLimits?: Maybe<TCategoryLimits>;
+    customObjects?: Maybe<TCustomObjectLimits>;
+    customerGroups?: Maybe<TCustomerGroupLimits>;
+    customers?: Maybe<TCustomerLimits>;
+    extensions?: Maybe<TExtensionLimits>;
+    orderEdits?: Maybe<TOrderEditLimits>;
+    productDiscounts?: Maybe<TProductDiscountLimits>;
+    productTypeLimits?: Maybe<TProductTypeLimits>;
+    products?: Maybe<TProductLimits>;
+    queryLimits?: Maybe<TQueryLimits>;
+    refreshTokens?: Maybe<TRefreshTokenLimits>;
+    searchLimits?: Maybe<TSearchLimits>;
+    shippingMethods?: Maybe<TShippingMethodLimit>;
+    shoppingLists?: Maybe<TShoppingListLimits>;
+    stores?: Maybe<TStoreLimits>;
+    taxCategories?: Maybe<TTaxCategoryLimit>;
+    termFacetSize?: Maybe<Scalars['Int']>;
+    zones?: Maybe<TZoneLimits>;
+};
+export declare type TProjectDraftType = {
+    asyncInitialization?: InputMaybe<Scalars['Boolean']>;
+    cdnContainerEnabled?: InputMaybe<Scalars['Boolean']>;
+    countries?: Array<Scalars['Country']>;
+    currencies: Array<Scalars['Currency']>;
+    dbClustersConfig?: InputMaybe<TDbClustersConfigInput>;
+    deleteDaysAfterCreation?: InputMaybe<Scalars['Int']>;
+    esCluster?: InputMaybe<TEsClusterInput>;
+    externalOAuth?: InputMaybe<TExternalOAuthInput>;
+    key: Scalars['String'];
+    languages: Array<Scalars['Locale']>;
+    messagesEnabled?: InputMaybe<Scalars['Boolean']>;
+    name: Scalars['String'];
+    owner: TReferenceInput;
+    plan: TProjectPlan;
+    searchIndexing?: InputMaybe<TSearchIndexingConfigurationInput>;
+    trialUntil?: InputMaybe<Scalars['DateTime']>;
+};
+export declare enum TProjectPlan {
+    Standard = "Standard",
+    Unlimited = "Unlimited"
+}
+export declare type TProjectQueryResult = {
+    __typename?: 'ProjectQueryResult';
+    count: Scalars['Int'];
+    /** BETA: This feature can be subject to change and should be used carefully in production. https://docs.commercetools.com/api/contract#public-beta */
+    exists: Scalars['Boolean'];
+    offset: Scalars['Int'];
+    results: Array<TProject>;
+    total: Scalars['Long'];
+};
+export declare type TProjectSuspendData = {
+    __typename?: 'ProjectSuspendData';
+    description?: Maybe<Scalars['String']>;
+    reason: TProjectSuspensionReason;
+};
+export declare enum TProjectSuspensionReason {
+    /** A database migration is running. */
+    DbMigration = "DbMigration",
+    /** Other reasons like copy project. */
+    Other = "Other",
+    /** The usage of the project is not paid. */
+    Payment = "Payment"
+}
+export declare type TPublicContainer = {
+    __typename?: 'PublicContainer';
+    httpUri: Scalars['String'];
+    httpsUri: Scalars['String'];
+    iosUri: Scalars['String'];
+    name: Scalars['String'];
+    streamingUri: Scalars['String'];
+};
+export declare type TQuery = {
+    __typename?: 'Query';
+    /**
+     * Fetch projects that `me` can access (but maybe not be able to manage).
+     * @deprecated beta feature
+     */
+    myAccessibleProjects: TProjectQueryResult;
+    /** Fetch organizations that `me` can manage. */
+    myOrganizations: TOrganizationQueryResult;
+    /**
+     * Fetch permissions `me` is allowed to see:
+     *  - if `owner` = `organization`: filter on organizations `me` can manage
+     *  - if `owner` = `project`: filter on projects belonging to organizations `me` can manage
+     * Currently in beta.
+     *
+     */
+    myPermissions: TPermissionQueryResult;
+    /** Fetch projects that `me` can manage. */
+    myProjects: TProjectQueryResult;
+    permissions: TPermissionQueryResult;
+    /** All permissions for a given user and a given owner (organization or project). Currently in beta. */
+    permissionsForUser: TPermissionQueryResult;
+    projects: TProjectQueryResult;
+};
+export declare type TQuery_MyAccessibleProjectsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_MyOrganizationsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_MyPermissionsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    owner: TReferenceInput;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_MyProjectsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_PermissionsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_PermissionsForUserArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    owner: TReferenceInput;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    userId: Scalars['String'];
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQuery_ProjectsArgs = {
+    limit?: InputMaybe<Scalars['Int']>;
+    offset?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<Array<Scalars['String']>>;
+    where?: InputMaybe<Scalars['String']>;
+};
+export declare type TQueryLimits = {
+    __typename?: 'QueryLimits';
+    maxOffset: Scalars['Int'];
+};
+export declare type TReference = {
+    __typename?: 'Reference';
+    id: Scalars['String'];
+    typeId: Scalars['String'];
+};
+export declare type TReferenceInput = {
+    id: Scalars['String'];
+    typeId: Scalars['String'];
+};
+export declare type TRefreshTokenLimits = {
+    __typename?: 'RefreshTokenLimits';
+    maxRefreshTokens?: Maybe<Scalars['Long']>;
+};
+export declare type TRemoveTeam = {
+    teamId: Scalars['String'];
+};
+export declare type TRemoveTeamMembership = {
+    teamId: Scalars['String'];
+    user: TReferenceInput;
+};
+export declare type TSearchIndexingConfigurationInput = {
+    products?: InputMaybe<TSearchIndexingConfigurationValuesInput>;
+};
+export declare type TSearchIndexingConfigurationValuesInput = {
+    status?: InputMaybe<Scalars['String']>;
+};
+export declare type TSearchLimits = {
+    __typename?: 'SearchLimits';
+    maxTextSize?: Maybe<Scalars['Int']>;
+};
+export declare type TSetPermissionActionRightPermissions = {
+    actionRightPermissions: Array<Scalars['String']>;
+};
+export declare type TSetPermissionDataFences = {
+    dataFences: Array<TDataFenceDraft>;
+};
+export declare type TSetPermissionHiddenMenuItems = {
+    hiddenMenuItems: Array<Scalars['String']>;
+};
+export declare type TSetPermissionResourceAccessPermissions = {
+    resourceAccessPermissions: Array<Scalars['String']>;
+};
+export declare type TShippingMethodLimit = {
+    __typename?: 'ShippingMethodLimit';
+    maxShippingMethods?: Maybe<Scalars['Long']>;
+};
+export declare type TShippingRateInputLocalizedEnumValue = {
+    __typename?: 'ShippingRateInputLocalizedEnumValue';
+    key: Scalars['String'];
+    label?: Maybe<Scalars['String']>;
+    labelAllLocales: Array<TLocalizedString>;
+};
+export declare type TShippingRateInputLocalizedEnumValue_LabelArgs = {
+    acceptLanguage?: InputMaybe<Array<Scalars['Locale']>>;
+    locale?: InputMaybe<Scalars['Locale']>;
+};
+export declare type TShippingRateInputType = {
+    type: Scalars['String'];
+};
+export declare type TShoppingListLimits = {
+    __typename?: 'ShoppingListLimits';
+    maxLineItems?: Maybe<Scalars['Int']>;
+    maxShoppingLists?: Maybe<Scalars['Long']>;
+    maxTextLineItems?: Maybe<Scalars['Int']>;
+};
+export declare type TStoreDataFence = TDataFence & {
+    __typename?: 'StoreDataFence';
+    storeKeys: Array<Scalars['String']>;
+    type: Scalars['String'];
+};
+export declare type TStoreLimits = {
+    __typename?: 'StoreLimits';
+    maxInventorySupplyChannelsPerStore?: Maybe<Scalars['Long']>;
+    maxProductDistributionChannelsPerStore?: Maybe<Scalars['Long']>;
+    maxProductSelectionsPerStore?: Maybe<Scalars['Long']>;
+    maxStores?: Maybe<Scalars['Long']>;
+};
+export declare type TTaxCategoryLimit = {
+    __typename?: 'TaxCategoryLimit';
+    maxTaxCategories?: Maybe<Scalars['Long']>;
+};
+export declare type TTeam = {
+    __typename?: 'Team';
+    id: Scalars['String'];
+    members: Array<TUser>;
+    membersRef: Array<TReference>;
+    name: Scalars['String'];
+};
+export declare type TUser = TVersioned & {
+    __typename?: 'User';
+    businessRole?: Maybe<TBusinessRole>;
+    createdAt: Scalars['DateTime'];
+    createdBy?: Maybe<TInitiator>;
+    email: Scalars['String'];
+    firstName: Scalars['String'];
+    id: Scalars['String'];
+    language: Scalars['Locale'];
+    lastModifiedAt: Scalars['DateTime'];
+    lastModifiedBy?: Maybe<TInitiator>;
+    lastName: Scalars['String'];
+    locked: Scalars['Boolean'];
+    lowercaseEmail: Scalars['String'];
+    numberFormat: Scalars['Locale'];
+    timeZone?: Maybe<Scalars['DateTimeZone']>;
+    version: Scalars['Long'];
+};
+/** Versioned object have an ID and version and modification. Every update of this object changes it's version. */
+export declare type TVersioned = {
+    createdAt: Scalars['DateTime'];
+    createdBy?: Maybe<TInitiator>;
+    id: Scalars['String'];
+    lastModifiedAt: Scalars['DateTime'];
+    lastModifiedBy?: Maybe<TInitiator>;
+    version: Scalars['Long'];
+};
+export declare type TZoneLimits = {
+    __typename?: 'ZoneLimits';
+    maxZones?: Maybe<Scalars['Long']>;
+};
+export declare type TFetchMyOrganizationsFromCliQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type TFetchMyOrganizationsFromCliQuery = {
+    __typename?: 'Query';
+    myOrganizations: {
+        __typename?: 'OrganizationQueryResult';
+        total: any;
+        results: Array<{
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+        }>;
+    };
+};