@mirahi/vendure-adyen-dropin-plugin/src/lib/plugin/generated-types/graphql.d.ts

A Vendure plugin to integrate the Adyen payment provider to your server. This plugin only handles the flow for a drop-in integration on your storefront.

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;
    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
    DateTime: any;
    /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
    JSON: any;
    /** The `Upload` scalar type represents a file upload. */
    Upload: any;
};
export declare type AddFulfillmentToOrderResult = CreateFulfillmentError | EmptyOrderLineSelectionError | Fulfillment | FulfillmentStateTransitionError | InsufficientStockOnHandError | InvalidFulfillmentHandlerError | ItemsAlreadyFulfilledError;
export declare type AddItemInput = {
    customFields?: InputMaybe<OrderLineCustomFieldsInput>;
    productVariantId: Scalars['ID'];
    quantity: Scalars['Int'];
};
export declare type AddItemToDraftOrderInput = {
    customFields?: InputMaybe<OrderLineCustomFieldsInput>;
    productVariantId: Scalars['ID'];
    quantity: Scalars['Int'];
};
export declare type AddManualPaymentToOrderResult = ManualPaymentStateError | Order;
export declare type AddNoteToCustomerInput = {
    id: Scalars['ID'];
    isPublic: Scalars['Boolean'];
    note: Scalars['String'];
};
export declare type AddNoteToOrderInput = {
    id: Scalars['ID'];
    isPublic: Scalars['Boolean'];
    note: Scalars['String'];
};
export declare type Address = Node & {
    __typename?: 'Address';
    city?: Maybe<Scalars['String']>;
    company?: Maybe<Scalars['String']>;
    country: Country;
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
    fullName?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    phoneNumber?: Maybe<Scalars['String']>;
    postalCode?: Maybe<Scalars['String']>;
    province?: Maybe<Scalars['String']>;
    streetLine1: Scalars['String'];
    streetLine2?: Maybe<Scalars['String']>;
    updatedAt: Scalars['DateTime'];
};
export declare type AdjustDraftOrderLineInput = {
    customFields?: InputMaybe<OrderLineCustomFieldsInput>;
    orderLineId: Scalars['ID'];
    quantity: Scalars['Int'];
};
export declare type AdjustOrderLineInput = {
    customFields?: InputMaybe<OrderLineCustomFieldsInput>;
    orderLineId: Scalars['ID'];
    quantity: Scalars['Int'];
};
export declare type Adjustment = {
    __typename?: 'Adjustment';
    adjustmentSource: Scalars['String'];
    amount: Scalars['Int'];
    description: Scalars['String'];
    type: AdjustmentType;
};
export declare enum AdjustmentType {
    DistributedOrderPromotion = "DISTRIBUTED_ORDER_PROMOTION",
    Other = "OTHER",
    Promotion = "PROMOTION"
}
export declare type Administrator = Node & {
    __typename?: 'Administrator';
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    emailAddress: Scalars['String'];
    firstName: Scalars['String'];
    id: Scalars['ID'];
    lastName: Scalars['String'];
    updatedAt: Scalars['DateTime'];
    user: User;
};
export declare type AdministratorFilterParameter = {
    createdAt?: InputMaybe<DateOperators>;
    emailAddress?: InputMaybe<StringOperators>;
    firstName?: InputMaybe<StringOperators>;
    id?: InputMaybe<IdOperators>;
    lastName?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type AdministratorList = PaginatedList & {
    __typename?: 'AdministratorList';
    items: Array<Administrator>;
    totalItems: Scalars['Int'];
};
export declare type AdministratorListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<AdministratorFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<AdministratorSortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type AdministratorPaymentInput = {
    metadata?: InputMaybe<Scalars['JSON']>;
    paymentMethod?: InputMaybe<Scalars['String']>;
};
export declare type AdministratorRefundInput = {
    paymentId: Scalars['ID'];
    reason?: InputMaybe<Scalars['String']>;
};
export declare type AdministratorSortParameter = {
    createdAt?: InputMaybe<SortOrder>;
    emailAddress?: InputMaybe<SortOrder>;
    firstName?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    lastName?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
export declare type AdyenPaymentIntent = {
    __typename?: 'AdyenPaymentIntent';
    sessionData?: Maybe<Scalars['String']>;
    transactionId?: Maybe<Scalars['String']>;
};
export declare type AdyenPaymentIntentError = {
    __typename?: 'AdyenPaymentIntentError';
    message: Scalars['String'];
};
export declare type AdyenPaymentIntentResult = AdyenPaymentIntent | AdyenPaymentIntentError;
export declare type Allocation = Node & StockMovement & {
    __typename?: 'Allocation';
    createdAt: Scalars['DateTime'];
    id: Scalars['ID'];
    orderLine: OrderLine;
    productVariant: ProductVariant;
    quantity: Scalars['Int'];
    type: StockMovementType;
    updatedAt: Scalars['DateTime'];
};
/** Returned if an attempting to refund an OrderItem which has already been refunded */
export declare type AlreadyRefundedError = ErrorResult & {
    __typename?: 'AlreadyRefundedError';
    errorCode: ErrorCode;
    message: Scalars['String'];
    refundId: Scalars['ID'];
};
export declare type ApplyCouponCodeResult = CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError | Order;
export declare type Asset = Node & {
    __typename?: 'Asset';
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    fileSize: Scalars['Int'];
    focalPoint?: Maybe<Coordinate>;
    height: Scalars['Int'];
    id: Scalars['ID'];
    mimeType: Scalars['String'];
    name: Scalars['String'];
    preview: Scalars['String'];
    source: Scalars['String'];
    tags: Array<Tag>;
    type: AssetType;
    updatedAt: Scalars['DateTime'];
    width: Scalars['Int'];
};
export declare type AssetFilterParameter = {
    createdAt?: InputMaybe<DateOperators>;
    fileSize?: InputMaybe<NumberOperators>;
    height?: InputMaybe<NumberOperators>;
    id?: InputMaybe<IdOperators>;
    mimeType?: InputMaybe<StringOperators>;
    name?: InputMaybe<StringOperators>;
    preview?: InputMaybe<StringOperators>;
    source?: InputMaybe<StringOperators>;
    type?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
    width?: InputMaybe<NumberOperators>;
};
export declare type AssetList = PaginatedList & {
    __typename?: 'AssetList';
    items: Array<Asset>;
    totalItems: Scalars['Int'];
};
export declare type AssetListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<AssetFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<AssetSortParameter>;
    tags?: InputMaybe<Array<Scalars['String']>>;
    tagsOperator?: InputMaybe<LogicalOperator>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type AssetSortParameter = {
    createdAt?: InputMaybe<SortOrder>;
    fileSize?: InputMaybe<SortOrder>;
    height?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    mimeType?: InputMaybe<SortOrder>;
    name?: InputMaybe<SortOrder>;
    preview?: InputMaybe<SortOrder>;
    source?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
    width?: InputMaybe<SortOrder>;
};
export declare enum AssetType {
    Binary = "BINARY",
    Image = "IMAGE",
    Video = "VIDEO"
}
export declare type AssignAssetsToChannelInput = {
    assetIds: Array<Scalars['ID']>;
    channelId: Scalars['ID'];
};
export declare type AssignCollectionsToChannelInput = {
    channelId: Scalars['ID'];
    collectionIds: Array<Scalars['ID']>;
};
export declare type AssignFacetsToChannelInput = {
    channelId: Scalars['ID'];
    facetIds: Array<Scalars['ID']>;
};
export declare type AssignProductVariantsToChannelInput = {
    channelId: Scalars['ID'];
    priceFactor?: InputMaybe<Scalars['Float']>;
    productVariantIds: Array<Scalars['ID']>;
};
export declare type AssignProductsToChannelInput = {
    channelId: Scalars['ID'];
    priceFactor?: InputMaybe<Scalars['Float']>;
    productIds: Array<Scalars['ID']>;
};
export declare type AssignPromotionsToChannelInput = {
    channelId: Scalars['ID'];
    promotionIds: Array<Scalars['ID']>;
};
export declare type AuthenticationInput = {
    native?: InputMaybe<NativeAuthInput>;
};
export declare type AuthenticationMethod = Node & {
    __typename?: 'AuthenticationMethod';
    createdAt: Scalars['DateTime'];
    id: Scalars['ID'];
    strategy: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
export declare type AuthenticationResult = CurrentUser | InvalidCredentialsError;
export declare type BooleanCustomFieldConfig = CustomField & {
    __typename?: 'BooleanCustomFieldConfig';
    description?: Maybe<Array<LocalizedString>>;
    internal?: Maybe<Scalars['Boolean']>;
    label?: Maybe<Array<LocalizedString>>;
    list: Scalars['Boolean'];
    name: Scalars['String'];
    nullable?: Maybe<Scalars['Boolean']>;
    readonly?: Maybe<Scalars['Boolean']>;
    type: Scalars['String'];
    ui?: Maybe<Scalars['JSON']>;
};
/** Operators for filtering on a list of Boolean fields */
export declare type BooleanListOperators = {
    inList: Scalars['Boolean'];
};
/** Operators for filtering on a Boolean field */
export declare type BooleanOperators = {
    eq?: InputMaybe<Scalars['Boolean']>;
    isNull?: InputMaybe<Scalars['Boolean']>;
};
/** Returned if an attempting to cancel lines from an Order which is still active */
export declare type CancelActiveOrderError = ErrorResult & {
    __typename?: 'CancelActiveOrderError';
    errorCode: ErrorCode;
    message: Scalars['String'];
    orderState: Scalars['String'];
};
export declare type CancelOrderInput = {
    /** Specify whether the shipping charges should also be cancelled. Defaults to false */
    cancelShipping?: InputMaybe<Scalars['Boolean']>;
    /** Optionally specify which OrderLines to cancel. If not provided, all OrderLines will be cancelled */
    lines?: InputMaybe<Array<OrderLineInput>>;
    /** The id of the order to be cancelled */
    orderId: Scalars['ID'];
    reason?: InputMaybe<Scalars['String']>;
};
export declare type CancelOrderResult = CancelActiveOrderError | EmptyOrderLineSelectionError | MultipleOrderError | Order | OrderStateTransitionError | QuantityTooGreatError;
/** Returned if the Payment cancellation fails */
export declare type CancelPaymentError = ErrorResult & {
    __typename?: 'CancelPaymentError';
    errorCode: ErrorCode;
    message: Scalars['String'];
    paymentErrorMessage: Scalars['String'];
};
export declare type CancelPaymentResult = CancelPaymentError | Payment | PaymentStateTransitionError;
export declare type Cancellation = Node & StockMovement & {
    __typename?: 'Cancellation';
    createdAt: Scalars['DateTime'];
    id: Scalars['ID'];
    orderLine: OrderLine;
    productVariant: ProductVariant;
    quantity: Scalars['Int'];
    type: StockMovementType;
    updatedAt: Scalars['DateTime'];
};
export declare type Channel = Node & {
    __typename?: 'Channel';
    code: Scalars['String'];
    createdAt: Scalars['DateTime'];
    currencyCode: CurrencyCode;
    customFields?: Maybe<Scalars['JSON']>;
    defaultLanguageCode: LanguageCode;
    defaultShippingZone?: Maybe<Zone>;
    defaultTaxZone?: Maybe<Zone>;
    id: Scalars['ID'];
    pricesIncludeTax: Scalars['Boolean'];
    token: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
/**
 * Returned when the default LanguageCode of a Channel is no longer found in the `availableLanguages`
 * of the GlobalSettings
 */
export declare type ChannelDefaultLanguageError = ErrorResult & {
    __typename?: 'ChannelDefaultLanguageError';
    channelCode: Scalars['String'];
    errorCode: ErrorCode;
    language: Scalars['String'];
    message: Scalars['String'];
};
export declare type Collection = Node & {
    __typename?: 'Collection';
    assets: Array<Asset>;
    breadcrumbs: Array<CollectionBreadcrumb>;
    children?: Maybe<Array<Collection>>;
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    description: Scalars['String'];
    featuredAsset?: Maybe<Asset>;
    filters: Array<ConfigurableOperation>;
    id: Scalars['ID'];
    isPrivate: Scalars['Boolean'];
    languageCode?: Maybe<LanguageCode>;
    name: Scalars['String'];
    parent?: Maybe<Collection>;
    position: Scalars['Int'];
    productVariants: ProductVariantList;
    slug: Scalars['String'];
    translations: Array<CollectionTranslation>;
    updatedAt: Scalars['DateTime'];
};
export declare type CollectionProductVariantsArgs = {
    options?: InputMaybe<ProductVariantListOptions>;
};
export declare type CollectionBreadcrumb = {
    __typename?: 'CollectionBreadcrumb';
    id: Scalars['ID'];
    name: Scalars['String'];
    slug: Scalars['String'];
};
export declare type CollectionFilterParameter = {
    createdAt?: InputMaybe<DateOperators>;
    description?: InputMaybe<StringOperators>;
    id?: InputMaybe<IdOperators>;
    isPrivate?: InputMaybe<BooleanOperators>;
    languageCode?: InputMaybe<StringOperators>;
    name?: InputMaybe<StringOperators>;
    position?: InputMaybe<NumberOperators>;
    slug?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type CollectionList = PaginatedList & {
    __typename?: 'CollectionList';
    items: Array<Collection>;
    totalItems: Scalars['Int'];
};
export declare type CollectionListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<CollectionFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<CollectionSortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
/**
 * Which Collections are present in the products returned
 * by the search, and in what quantity.
 */
export declare type CollectionResult = {
    __typename?: 'CollectionResult';
    collection: Collection;
    count: Scalars['Int'];
};
export declare type CollectionSortParameter = {
    createdAt?: InputMaybe<SortOrder>;
    description?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    name?: InputMaybe<SortOrder>;
    position?: InputMaybe<SortOrder>;
    slug?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
export declare type CollectionTranslation = {
    __typename?: 'CollectionTranslation';
    createdAt: Scalars['DateTime'];
    description: Scalars['String'];
    id: Scalars['ID'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    slug: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
export declare type ConfigArg = {
    __typename?: 'ConfigArg';
    name: Scalars['String'];
    value: Scalars['String'];
};
export declare type ConfigArgDefinition = {
    __typename?: 'ConfigArgDefinition';
    defaultValue?: Maybe<Scalars['JSON']>;
    description?: Maybe<Scalars['String']>;
    label?: Maybe<Scalars['String']>;
    list: Scalars['Boolean'];
    name: Scalars['String'];
    required: Scalars['Boolean'];
    type: Scalars['String'];
    ui?: Maybe<Scalars['JSON']>;
};
export declare type ConfigArgInput = {
    name: Scalars['String'];
    /** A JSON stringified representation of the actual value */
    value: Scalars['String'];
};
export declare type ConfigurableOperation = {
    __typename?: 'ConfigurableOperation';
    args: Array<ConfigArg>;
    code: Scalars['String'];
};
export declare type ConfigurableOperationDefinition = {
    __typename?: 'ConfigurableOperationDefinition';
    args: Array<ConfigArgDefinition>;
    code: Scalars['String'];
    description: Scalars['String'];
};
export declare type ConfigurableOperationInput = {
    arguments: Array<ConfigArgInput>;
    code: Scalars['String'];
};
export declare type Coordinate = {
    __typename?: 'Coordinate';
    x: Scalars['Float'];
    y: Scalars['Float'];
};
export declare type CoordinateInput = {
    x: Scalars['Float'];
    y: Scalars['Float'];
};
export declare type Country = Node & {
    __typename?: 'Country';
    code: Scalars['String'];
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    enabled: Scalars['Boolean'];
    id: Scalars['ID'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    translations: Array<CountryTranslation>;
    updatedAt: Scalars['DateTime'];
};
export declare type CountryFilterParameter = {
    code?: InputMaybe<StringOperators>;
    createdAt?: InputMaybe<DateOperators>;
    enabled?: InputMaybe<BooleanOperators>;
    id?: InputMaybe<IdOperators>;
    languageCode?: InputMaybe<StringOperators>;
    name?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type CountryList = PaginatedList & {
    __typename?: 'CountryList';
    items: Array<Country>;
    totalItems: Scalars['Int'];
};
export declare type CountryListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<CountryFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<CountrySortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type CountrySortParameter = {
    code?: InputMaybe<SortOrder>;
    createdAt?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    name?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
export declare type CountryTranslation = {
    __typename?: 'CountryTranslation';
    createdAt: Scalars['DateTime'];
    id: Scalars['ID'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
export declare type CountryTranslationInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    id?: InputMaybe<Scalars['ID']>;
    languageCode: LanguageCode;
    name?: InputMaybe<Scalars['String']>;
};
/** Returned if the provided coupon code is invalid */
export declare type CouponCodeExpiredError = ErrorResult & {
    __typename?: 'CouponCodeExpiredError';
    couponCode: Scalars['String'];
    errorCode: ErrorCode;
    message: Scalars['String'];
};
/** Returned if the provided coupon code is invalid */
export declare type CouponCodeInvalidError = ErrorResult & {
    __typename?: 'CouponCodeInvalidError';
    couponCode: Scalars['String'];
    errorCode: ErrorCode;
    message: Scalars['String'];
};
/** Returned if the provided coupon code is invalid */
export declare type CouponCodeLimitError = ErrorResult & {
    __typename?: 'CouponCodeLimitError';
    couponCode: Scalars['String'];
    errorCode: ErrorCode;
    limit: Scalars['Int'];
    message: Scalars['String'];
};
export declare type CreateAddressInput = {
    city?: InputMaybe<Scalars['String']>;
    company?: InputMaybe<Scalars['String']>;
    countryCode: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
    defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
    fullName?: InputMaybe<Scalars['String']>;
    phoneNumber?: InputMaybe<Scalars['String']>;
    postalCode?: InputMaybe<Scalars['String']>;
    province?: InputMaybe<Scalars['String']>;
    streetLine1: Scalars['String'];
    streetLine2?: InputMaybe<Scalars['String']>;
};
export declare type CreateAdministratorInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    emailAddress: Scalars['String'];
    firstName: Scalars['String'];
    lastName: Scalars['String'];
    password: Scalars['String'];
    roleIds: Array<Scalars['ID']>;
};
export declare type CreateAssetInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    file: Scalars['Upload'];
    tags?: InputMaybe<Array<Scalars['String']>>;
};
export declare type CreateAssetResult = Asset | MimeTypeError;
export declare type CreateChannelInput = {
    code: Scalars['String'];
    currencyCode: CurrencyCode;
    customFields?: InputMaybe<Scalars['JSON']>;
    defaultLanguageCode: LanguageCode;
    defaultShippingZoneId: Scalars['ID'];
    defaultTaxZoneId: Scalars['ID'];
    pricesIncludeTax: Scalars['Boolean'];
    token: Scalars['String'];
};
export declare type CreateChannelResult = Channel | LanguageNotAvailableError;
export declare type CreateCollectionInput = {
    assetIds?: InputMaybe<Array<Scalars['ID']>>;
    customFields?: InputMaybe<Scalars['JSON']>;
    featuredAssetId?: InputMaybe<Scalars['ID']>;
    filters: Array<ConfigurableOperationInput>;
    isPrivate?: InputMaybe<Scalars['Boolean']>;
    parentId?: InputMaybe<Scalars['ID']>;
    translations: Array<CreateCollectionTranslationInput>;
};
export declare type CreateCollectionTranslationInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    description: Scalars['String'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    slug: Scalars['String'];
};
export declare type CreateCountryInput = {
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    enabled: Scalars['Boolean'];
    translations: Array<CountryTranslationInput>;
};
export declare type CreateCustomerGroupInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    customerIds?: InputMaybe<Array<Scalars['ID']>>;
    name: Scalars['String'];
};
export declare type CreateCustomerInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    emailAddress: Scalars['String'];
    firstName: Scalars['String'];
    lastName: Scalars['String'];
    phoneNumber?: InputMaybe<Scalars['String']>;
    title?: InputMaybe<Scalars['String']>;
};
export declare type CreateCustomerResult = Customer | EmailAddressConflictError;
export declare type CreateFacetInput = {
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    isPrivate: Scalars['Boolean'];
    translations: Array<FacetTranslationInput>;
    values?: InputMaybe<Array<CreateFacetValueWithFacetInput>>;
};
export declare type CreateFacetValueInput = {
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    facetId: Scalars['ID'];
    translations: Array<FacetValueTranslationInput>;
};
export declare type CreateFacetValueWithFacetInput = {
    code: Scalars['String'];
    translations: Array<FacetValueTranslationInput>;
};
/** Returned if an error is thrown in a FulfillmentHandler's createFulfillment method */
export declare type CreateFulfillmentError = ErrorResult & {
    __typename?: 'CreateFulfillmentError';
    errorCode: ErrorCode;
    fulfillmentHandlerError: Scalars['String'];
    message: Scalars['String'];
};
export declare type CreateGroupOptionInput = {
    code: Scalars['String'];
    translations: Array<ProductOptionGroupTranslationInput>;
};
export declare type CreatePaymentMethodInput = {
    checker?: InputMaybe<ConfigurableOperationInput>;
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    description?: InputMaybe<Scalars['String']>;
    enabled: Scalars['Boolean'];
    handler: ConfigurableOperationInput;
    name: Scalars['String'];
};
export declare type CreateProductCustomFieldsInput = {
    asSupplementMaxAmount?: InputMaybe<Scalars['Int']>;
    required?: InputMaybe<Scalars['Boolean']>;
};
export declare type CreateProductInput = {
    assetIds?: InputMaybe<Array<Scalars['ID']>>;
    customFields?: InputMaybe<CreateProductCustomFieldsInput>;
    enabled?: InputMaybe<Scalars['Boolean']>;
    facetValueIds?: InputMaybe<Array<Scalars['ID']>>;
    featuredAssetId?: InputMaybe<Scalars['ID']>;
    translations: Array<ProductTranslationInput>;
};
export declare type CreateProductOptionGroupInput = {
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    options: Array<CreateGroupOptionInput>;
    translations: Array<ProductOptionGroupTranslationInput>;
};
export declare type CreateProductOptionInput = {
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    productOptionGroupId: Scalars['ID'];
    translations: Array<ProductOptionGroupTranslationInput>;
};
export declare type CreateProductVariantCustomFieldsInput = {
    ingredients?: InputMaybe<Array<Scalars['String']>>;
    priceAsSupplement?: InputMaybe<Scalars['Float']>;
    supplementGroupsIds?: InputMaybe<Array<Scalars['ID']>>;
};
export declare type CreateProductVariantInput = {
    assetIds?: InputMaybe<Array<Scalars['ID']>>;
    customFields?: InputMaybe<CreateProductVariantCustomFieldsInput>;
    facetValueIds?: InputMaybe<Array<Scalars['ID']>>;
    featuredAssetId?: InputMaybe<Scalars['ID']>;
    optionIds?: InputMaybe<Array<Scalars['ID']>>;
    outOfStockThreshold?: InputMaybe<Scalars['Int']>;
    price?: InputMaybe<Scalars['Int']>;
    productId: Scalars['ID'];
    sku: Scalars['String'];
    stockOnHand?: InputMaybe<Scalars['Int']>;
    taxCategoryId?: InputMaybe<Scalars['ID']>;
    trackInventory?: InputMaybe<GlobalFlag>;
    translations: Array<ProductVariantTranslationInput>;
    useGlobalOutOfStockThreshold?: InputMaybe<Scalars['Boolean']>;
};
export declare type CreateProductVariantOptionInput = {
    code: Scalars['String'];
    optionGroupId: Scalars['ID'];
    translations: Array<ProductOptionTranslationInput>;
};
export declare type CreatePromotionInput = {
    actions: Array<ConfigurableOperationInput>;
    conditions: Array<ConfigurableOperationInput>;
    couponCode?: InputMaybe<Scalars['String']>;
    customFields?: InputMaybe<Scalars['JSON']>;
    enabled: Scalars['Boolean'];
    endsAt?: InputMaybe<Scalars['DateTime']>;
    name: Scalars['String'];
    perCustomerUsageLimit?: InputMaybe<Scalars['Int']>;
    startsAt?: InputMaybe<Scalars['DateTime']>;
};
export declare type CreatePromotionResult = MissingConditionsError | Promotion;
export declare type CreateRoleInput = {
    channelIds?: InputMaybe<Array<Scalars['ID']>>;
    code: Scalars['String'];
    description: Scalars['String'];
    permissions: Array<Permission>;
};
export declare type CreateShippingMethodInput = {
    calculator: ConfigurableOperationInput;
    checker: ConfigurableOperationInput;
    code: Scalars['String'];
    customFields?: InputMaybe<Scalars['JSON']>;
    fulfillmentHandler: Scalars['String'];
    translations: Array<ShippingMethodTranslationInput>;
};
export declare type CreateTagInput = {
    value: Scalars['String'];
};
export declare type CreateTaxCategoryInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    isDefault?: InputMaybe<Scalars['Boolean']>;
    name: Scalars['String'];
};
export declare type CreateTaxRateInput = {
    categoryId: Scalars['ID'];
    customFields?: InputMaybe<Scalars['JSON']>;
    customerGroupId?: InputMaybe<Scalars['ID']>;
    enabled: Scalars['Boolean'];
    name: Scalars['String'];
    value: Scalars['Float'];
    zoneId: Scalars['ID'];
};
export declare type CreateZoneInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    memberIds?: InputMaybe<Array<Scalars['ID']>>;
    name: Scalars['String'];
};
/**
 * @description
 * ISO 4217 currency code
 *
 * @docsCategory common
 */
export declare enum CurrencyCode {
    /** United Arab Emirates dirham */
    Aed = "AED",
    /** Afghan afghani */
    Afn = "AFN",
    /** Albanian lek */
    All = "ALL",
    /** Armenian dram */
    Amd = "AMD",
    /** Netherlands Antillean guilder */
    Ang = "ANG",
    /** Angolan kwanza */
    Aoa = "AOA",
    /** Argentine peso */
    Ars = "ARS",
    /** Australian dollar */
    Aud = "AUD",
    /** Aruban florin */
    Awg = "AWG",
    /** Azerbaijani manat */
    Azn = "AZN",
    /** Bosnia and Herzegovina convertible mark */
    Bam = "BAM",
    /** Barbados dollar */
    Bbd = "BBD",
    /** Bangladeshi taka */
    Bdt = "BDT",
    /** Bulgarian lev */
    Bgn = "BGN",
    /** Bahraini dinar */
    Bhd = "BHD",
    /** Burundian franc */
    Bif = "BIF",
    /** Bermudian dollar */
    Bmd = "BMD",
    /** Brunei dollar */
    Bnd = "BND",
    /** Boliviano */
    Bob = "BOB",
    /** Brazilian real */
    Brl = "BRL",
    /** Bahamian dollar */
    Bsd = "BSD",
    /** Bhutanese ngultrum */
    Btn = "BTN",
    /** Botswana pula */
    Bwp = "BWP",
    /** Belarusian ruble */
    Byn = "BYN",
    /** Belize dollar */
    Bzd = "BZD",
    /** Canadian dollar */
    Cad = "CAD",
    /** Congolese franc */
    Cdf = "CDF",
    /** Swiss franc */
    Chf = "CHF",
    /** Chilean peso */
    Clp = "CLP",
    /** Renminbi (Chinese) yuan */
    Cny = "CNY",
    /** Colombian peso */
    Cop = "COP",
    /** Costa Rican colon */
    Crc = "CRC",
    /** Cuban convertible peso */
    Cuc = "CUC",
    /** Cuban peso */
    Cup = "CUP",
    /** Cape Verde escudo */
    Cve = "CVE",
    /** Czech koruna */
    Czk = "CZK",
    /** Djiboutian franc */
    Djf = "DJF",
    /** Danish krone */
    Dkk = "DKK",
    /** Dominican peso */
    Dop = "DOP",
    /** Algerian dinar */
    Dzd = "DZD",
    /** Egyptian pound */
    Egp = "EGP",
    /** Eritrean nakfa */
    Ern = "ERN",
    /** Ethiopian birr */
    Etb = "ETB",
    /** Euro */
    Eur = "EUR",
    /** Fiji dollar */
    Fjd = "FJD",
    /** Falkland Islands pound */
    Fkp = "FKP",
    /** Pound sterling */
    Gbp = "GBP",
    /** Georgian lari */
    Gel = "GEL",
    /** Ghanaian cedi */
    Ghs = "GHS",
    /** Gibraltar pound */
    Gip = "GIP",
    /** Gambian dalasi */
    Gmd = "GMD",
    /** Guinean franc */
    Gnf = "GNF",
    /** Guatemalan quetzal */
    Gtq = "GTQ",
    /** Guyanese dollar */
    Gyd = "GYD",
    /** Hong Kong dollar */
    Hkd = "HKD",
    /** Honduran lempira */
    Hnl = "HNL",
    /** Croatian kuna */
    Hrk = "HRK",
    /** Haitian gourde */
    Htg = "HTG",
    /** Hungarian forint */
    Huf = "HUF",
    /** Indonesian rupiah */
    Idr = "IDR",
    /** Israeli new shekel */
    Ils = "ILS",
    /** Indian rupee */
    Inr = "INR",
    /** Iraqi dinar */
    Iqd = "IQD",
    /** Iranian rial */
    Irr = "IRR",
    /** Icelandic króna */
    Isk = "ISK",
    /** Jamaican dollar */
    Jmd = "JMD",
    /** Jordanian dinar */
    Jod = "JOD",
    /** Japanese yen */
    Jpy = "JPY",
    /** Kenyan shilling */
    Kes = "KES",
    /** Kyrgyzstani som */
    Kgs = "KGS",
    /** Cambodian riel */
    Khr = "KHR",
    /** Comoro franc */
    Kmf = "KMF",
    /** North Korean won */
    Kpw = "KPW",
    /** South Korean won */
    Krw = "KRW",
    /** Kuwaiti dinar */
    Kwd = "KWD",
    /** Cayman Islands dollar */
    Kyd = "KYD",
    /** Kazakhstani tenge */
    Kzt = "KZT",
    /** Lao kip */
    Lak = "LAK",
    /** Lebanese pound */
    Lbp = "LBP",
    /** Sri Lankan rupee */
    Lkr = "LKR",
    /** Liberian dollar */
    Lrd = "LRD",
    /** Lesotho loti */
    Lsl = "LSL",
    /** Libyan dinar */
    Lyd = "LYD",
    /** Moroccan dirham */
    Mad = "MAD",
    /** Moldovan leu */
    Mdl = "MDL",
    /** Malagasy ariary */
    Mga = "MGA",
    /** Macedonian denar */
    Mkd = "MKD",
    /** Myanmar kyat */
    Mmk = "MMK",
    /** Mongolian tögrög */
    Mnt = "MNT",
    /** Macanese pataca */
    Mop = "MOP",
    /** Mauritanian ouguiya */
    Mru = "MRU",
    /** Mauritian rupee */
    Mur = "MUR",
    /** Maldivian rufiyaa */
    Mvr = "MVR",
    /** Malawian kwacha */
    Mwk = "MWK",
    /** Mexican peso */
    Mxn = "MXN",
    /** Malaysian ringgit */
    Myr = "MYR",
    /** Mozambican metical */
    Mzn = "MZN",
    /** Namibian dollar */
    Nad = "NAD",
    /** Nigerian naira */
    Ngn = "NGN",
    /** Nicaraguan córdoba */
    Nio = "NIO",
    /** Norwegian krone */
    Nok = "NOK",
    /** Nepalese rupee */
    Npr = "NPR",
    /** New Zealand dollar */
    Nzd = "NZD",
    /** Omani rial */
    Omr = "OMR",
    /** Panamanian balboa */
    Pab = "PAB",
    /** Peruvian sol */
    Pen = "PEN",
    /** Papua New Guinean kina */
    Pgk = "PGK",
    /** Philippine peso */
    Php = "PHP",
    /** Pakistani rupee */
    Pkr = "PKR",
    /** Polish złoty */
    Pln = "PLN",
    /** Paraguayan guaraní */
    Pyg = "PYG",
    /** Qatari riyal */
    Qar = "QAR",
    /** Romanian leu */
    Ron = "RON",
    /** Serbian dinar */
    Rsd = "RSD",
    /** Russian ruble */
    Rub = "RUB",
    /** Rwandan franc */
    Rwf = "RWF",
    /** Saudi riyal */
    Sar = "SAR",
    /** Solomon Islands dollar */
    Sbd = "SBD",
    /** Seychelles rupee */
    Scr = "SCR",
    /** Sudanese pound */
    Sdg = "SDG",
    /** Swedish krona/kronor */
    Sek = "SEK",
    /** Singapore dollar */
    Sgd = "SGD",
    /** Saint Helena pound */
    Shp = "SHP",
    /** Sierra Leonean leone */
    Sll = "SLL",
    /** Somali shilling */
    Sos = "SOS",
    /** Surinamese dollar */
    Srd = "SRD",
    /** South Sudanese pound */
    Ssp = "SSP",
    /** São Tomé and Príncipe dobra */
    Stn = "STN",
    /** Salvadoran colón */
    Svc = "SVC",
    /** Syrian pound */
    Syp = "SYP",
    /** Swazi lilangeni */
    Szl = "SZL",
    /** Thai baht */
    Thb = "THB",
    /** Tajikistani somoni */
    Tjs = "TJS",
    /** Turkmenistan manat */
    Tmt = "TMT",
    /** Tunisian dinar */
    Tnd = "TND",
    /** Tongan paʻanga */
    Top = "TOP",
    /** Turkish lira */
    Try = "TRY",
    /** Trinidad and Tobago dollar */
    Ttd = "TTD",
    /** New Taiwan dollar */
    Twd = "TWD",
    /** Tanzanian shilling */
    Tzs = "TZS",
    /** Ukrainian hryvnia */
    Uah = "UAH",
    /** Ugandan shilling */
    Ugx = "UGX",
    /** United States dollar */
    Usd = "USD",
    /** Uruguayan peso */
    Uyu = "UYU",
    /** Uzbekistan som */
    Uzs = "UZS",
    /** Venezuelan bolívar soberano */
    Ves = "VES",
    /** Vietnamese đồng */
    Vnd = "VND",
    /** Vanuatu vatu */
    Vuv = "VUV",
    /** Samoan tala */
    Wst = "WST",
    /** CFA franc BEAC */
    Xaf = "XAF",
    /** East Caribbean dollar */
    Xcd = "XCD",
    /** CFA franc BCEAO */
    Xof = "XOF",
    /** CFP franc (franc Pacifique) */
    Xpf = "XPF",
    /** Yemeni rial */
    Yer = "YER",
    /** South African rand */
    Zar = "ZAR",
    /** Zambian kwacha */
    Zmw = "ZMW",
    /** Zimbabwean dollar */
    Zwl = "ZWL"
}
export declare type CurrentUser = {
    __typename?: 'CurrentUser';
    channels: Array<CurrentUserChannel>;
    id: Scalars['ID'];
    identifier: Scalars['String'];
};
export declare type CurrentUserChannel = {
    __typename?: 'CurrentUserChannel';
    code: Scalars['String'];
    id: Scalars['ID'];
    permissions: Array<Permission>;
    token: Scalars['String'];
};
export declare type CustomField = {
    description?: Maybe<Array<LocalizedString>>;
    internal?: Maybe<Scalars['Boolean']>;
    label?: Maybe<Array<LocalizedString>>;
    list: Scalars['Boolean'];
    name: Scalars['String'];
    nullable?: Maybe<Scalars['Boolean']>;
    readonly?: Maybe<Scalars['Boolean']>;
    type: Scalars['String'];
    ui?: Maybe<Scalars['JSON']>;
};
export declare type CustomFieldConfig = BooleanCustomFieldConfig | DateTimeCustomFieldConfig | FloatCustomFieldConfig | IntCustomFieldConfig | LocaleStringCustomFieldConfig | RelationCustomFieldConfig | StringCustomFieldConfig | TextCustomFieldConfig;
export declare type CustomFields = {
    __typename?: 'CustomFields';
    Address: Array<CustomFieldConfig>;
    Administrator: Array<CustomFieldConfig>;
    Asset: Array<CustomFieldConfig>;
    Channel: Array<CustomFieldConfig>;
    Collection: Array<CustomFieldConfig>;
    Country: Array<CustomFieldConfig>;
    Customer: Array<CustomFieldConfig>;
    CustomerGroup: Array<CustomFieldConfig>;
    Facet: Array<CustomFieldConfig>;
    FacetValue: Array<CustomFieldConfig>;
    Fulfillment: Array<CustomFieldConfig>;
    GlobalSettings: Array<CustomFieldConfig>;
    Order: Array<CustomFieldConfig>;
    OrderLine: Array<CustomFieldConfig>;
    PaymentMethod: Array<CustomFieldConfig>;
    Product: Array<CustomFieldConfig>;
    ProductOption: Array<CustomFieldConfig>;
    ProductOptionGroup: Array<CustomFieldConfig>;
    ProductVariant: Array<CustomFieldConfig>;
    Promotion: Array<CustomFieldConfig>;
    ShippingMethod: Array<CustomFieldConfig>;
    TaxCategory: Array<CustomFieldConfig>;
    TaxRate: Array<CustomFieldConfig>;
    User: Array<CustomFieldConfig>;
    Zone: Array<CustomFieldConfig>;
};
export declare type Customer = Node & {
    __typename?: 'Customer';
    addresses?: Maybe<Array<Address>>;
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    emailAddress: Scalars['String'];
    firstName: Scalars['String'];
    groups: Array<CustomerGroup>;
    history: HistoryEntryList;
    id: Scalars['ID'];
    lastName: Scalars['String'];
    orders: OrderList;
    phoneNumber?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    updatedAt: Scalars['DateTime'];
    user?: Maybe<User>;
};
export declare type CustomerHistoryArgs = {
    options?: InputMaybe<HistoryEntryListOptions>;
};
export declare type CustomerOrdersArgs = {
    options?: InputMaybe<OrderListOptions>;
};
export declare type CustomerFilterParameter = {
    createdAt?: InputMaybe<DateOperators>;
    emailAddress?: InputMaybe<StringOperators>;
    firstName?: InputMaybe<StringOperators>;
    id?: InputMaybe<IdOperators>;
    lastName?: InputMaybe<StringOperators>;
    phoneNumber?: InputMaybe<StringOperators>;
    postalCode?: InputMaybe<StringOperators>;
    title?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type CustomerGroup = Node & {
    __typename?: 'CustomerGroup';
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    customers: CustomerList;
    id: Scalars['ID'];
    name: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
export declare type CustomerGroupCustomersArgs = {
    options?: InputMaybe<CustomerListOptions>;
};
export declare type CustomerGroupFilterParameter = {
    createdAt?: InputMaybe<DateOperators>;
    id?: InputMaybe<IdOperators>;
    name?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type CustomerGroupList = PaginatedList & {
    __typename?: 'CustomerGroupList';
    items: Array<CustomerGroup>;
    totalItems: Scalars['Int'];
};
export declare type CustomerGroupListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<CustomerGroupFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<CustomerGroupSortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type CustomerGroupSortParameter = {
    createdAt?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    name?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
export declare type CustomerList = PaginatedList & {
    __typename?: 'CustomerList';
    items: Array<Customer>;
    totalItems: Scalars['Int'];
};
export declare type CustomerListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<CustomerFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<CustomerSortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type CustomerSortParameter = {
    createdAt?: InputMaybe<SortOrder>;
    emailAddress?: InputMaybe<SortOrder>;
    firstName?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    lastName?: InputMaybe<SortOrder>;
    phoneNumber?: InputMaybe<SortOrder>;
    title?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
/** Operators for filtering on a list of Date fields */
export declare type DateListOperators = {
    inList: Scalars['DateTime'];
};
/** Operators for filtering on a DateTime field */
export declare type DateOperators = {
    after?: InputMaybe<Scalars['DateTime']>;
    before?: InputMaybe<Scalars['DateTime']>;
    between?: InputMaybe<DateRange>;
    eq?: InputMaybe<Scalars['DateTime']>;
    isNull?: InputMaybe<Scalars['Boolean']>;
};
export declare type DateRange = {
    end: Scalars['DateTime'];
    start: Scalars['DateTime'];
};
/**
 * Expects the same validation formats as the `<input type="datetime-local">` HTML element.
 * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes
 */
export declare type DateTimeCustomFieldConfig = CustomField & {
    __typename?: 'DateTimeCustomFieldConfig';
    description?: Maybe<Array<LocalizedString>>;
    internal?: Maybe<Scalars['Boolean']>;
    label?: Maybe<Array<LocalizedString>>;
    list: Scalars['Boolean'];
    max?: Maybe<Scalars['String']>;
    min?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    nullable?: Maybe<Scalars['Boolean']>;
    readonly?: Maybe<Scalars['Boolean']>;
    step?: Maybe<Scalars['Int']>;
    type: Scalars['String'];
    ui?: Maybe<Scalars['JSON']>;
};
export declare type DeleteAssetInput = {
    assetId: Scalars['ID'];
    deleteFromAllChannels?: InputMaybe<Scalars['Boolean']>;
    force?: InputMaybe<Scalars['Boolean']>;
};
export declare type DeleteAssetsInput = {
    assetIds: Array<Scalars['ID']>;
    deleteFromAllChannels?: InputMaybe<Scalars['Boolean']>;
    force?: InputMaybe<Scalars['Boolean']>;
};
export declare type DeletionResponse = {
    __typename?: 'DeletionResponse';
    message?: Maybe<Scalars['String']>;
    result: DeletionResult;
};
export declare enum DeletionResult {
    /** The entity was successfully deleted */
    Deleted = "DELETED",
    /** Deletion did not take place, reason given in message */
    NotDeleted = "NOT_DELETED"
}
export declare type Discount = {
    __typename?: 'Discount';
    adjustmentSource: Scalars['String'];
    amount: Scalars['Int'];
    amountWithTax: Scalars['Int'];
    description: Scalars['String'];
    type: AdjustmentType;
};
/** Returned when attempting to create a Customer with an email address already registered to an existing User. */
export declare type EmailAddressConflictError = ErrorResult & {
    __typename?: 'EmailAddressConflictError';
    errorCode: ErrorCode;
    message: Scalars['String'];
};
/** Returned if no OrderLines have been specified for the operation */
export declare type EmptyOrderLineSelectionError = ErrorResult & {
    __typename?: 'EmptyOrderLineSelectionError';
    errorCode: ErrorCode;
    message: Scalars['String'];
};
export declare enum ErrorCode {
    AlreadyRefundedError = "ALREADY_REFUNDED_ERROR",
    CancelActiveOrderError = "CANCEL_ACTIVE_ORDER_ERROR",
    CancelPaymentError = "CANCEL_PAYMENT_ERROR",
    ChannelDefaultLanguageError = "CHANNEL_DEFAULT_LANGUAGE_ERROR",
    CouponCodeExpiredError = "COUPON_CODE_EXPIRED_ERROR",
    CouponCodeInvalidError = "COUPON_CODE_INVALID_ERROR",
    CouponCodeLimitError = "COUPON_CODE_LIMIT_ERROR",
    CreateFulfillmentError = "CREATE_FULFILLMENT_ERROR",
    EmailAddressConflictError = "EMAIL_ADDRESS_CONFLICT_ERROR",
    EmptyOrderLineSelectionError = "EMPTY_ORDER_LINE_SELECTION_ERROR",
    FacetInUseError = "FACET_IN_USE_ERROR",
    FulfillmentStateTransitionError = "FULFILLMENT_STATE_TRANSITION_ERROR",
    IneligibleShippingMethodError = "INELIGIBLE_SHIPPING_METHOD_ERROR",
    InsufficientStockError = "INSUFFICIENT_STOCK_ERROR",
    InsufficientStockOnHandError = "INSUFFICIENT_STOCK_ON_HAND_ERROR",
    InvalidCredentialsError = "INVALID_CREDENTIALS_ERROR",
    InvalidFulfillmentHandlerError = "INVALID_FULFILLMENT_HANDLER_ERROR",
    ItemsAlreadyFulfilledError = "ITEMS_ALREADY_FULFILLED_ERROR",
    LanguageNotAvailableError = "LANGUAGE_NOT_AVAILABLE_ERROR",
    ManualPaymentStateError = "MANUAL_PAYMENT_STATE_ERROR",
    MimeTypeError = "MIME_TYPE_ERROR",
    MissingConditionsError = "MISSING_CONDITIONS_ERROR",
    MultipleOrderError = "MULTIPLE_ORDER_ERROR",
    NativeAuthStrategyError = "NATIVE_AUTH_STRATEGY_ERROR",
    NegativeQuantityError = "NEGATIVE_QUANTITY_ERROR",
    NothingToRefundError = "NOTHING_TO_REFUND_ERROR",
    NoActiveOrderError = "NO_ACTIVE_ORDER_ERROR",
    NoChangesSpecifiedError = "NO_CHANGES_SPECIFIED_ERROR",
    OrderLimitError = "ORDER_LIMIT_ERROR",
    OrderModificationError = "ORDER_MODIFICATION_ERROR",
    OrderModificationStateError = "ORDER_MODIFICATION_STATE_ERROR",
    OrderStateTransitionError = "ORDER_STATE_TRANSITION_ERROR",
    PaymentMethodMissingError = "PAYMENT_METHOD_MISSING_ERROR",
    PaymentOrderMismatchError = "PAYMENT_ORDER_MISMATCH_ERROR",
    PaymentStateTransitionError = "PAYMENT_STATE_TRANSITION_ERROR",
    ProductOptionInUseError = "PRODUCT_OPTION_IN_USE_ERROR",
    QuantityTooGreatError = "QUANTITY_TOO_GREAT_ERROR",
    RefundOrderStateError = "REFUND_ORDER_STATE_ERROR",
    RefundPaymentIdMissingError = "REFUND_PAYMENT_ID_MISSING_ERROR",
    RefundStateTransitionError = "REFUND_STATE_TRANSITION_ERROR",
    SettlePaymentError = "SETTLE_PAYMENT_ERROR",
    UnknownError = "UNKNOWN_ERROR"
}
export declare type ErrorResult = {
    errorCode: ErrorCode;
    message: Scalars['String'];
};
export declare type Facet = Node & {
    __typename?: 'Facet';
    code: Scalars['String'];
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;
    id: Scalars['ID'];
    isPrivate: Scalars['Boolean'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    translations: Array<FacetTranslation>;
    updatedAt: Scalars['DateTime'];
    values: Array<FacetValue>;
};
export declare type FacetFilterParameter = {
    code?: InputMaybe<StringOperators>;
    createdAt?: InputMaybe<DateOperators>;
    id?: InputMaybe<IdOperators>;
    isPrivate?: InputMaybe<BooleanOperators>;
    languageCode?: InputMaybe<StringOperators>;
    name?: InputMaybe<StringOperators>;
    updatedAt?: InputMaybe<DateOperators>;
};
export declare type FacetInUseError = ErrorResult & {
    __typename?: 'FacetInUseError';
    errorCode: ErrorCode;
    facetCode: Scalars['String'];
    message: Scalars['String'];
    productCount: Scalars['Int'];
    variantCount: Scalars['Int'];
};
export declare type FacetList = PaginatedList & {
    __typename?: 'FacetList';
    items: Array<Facet>;
    totalItems: Scalars['Int'];
};
export declare type FacetListOptions = {
    /** Allows the results to be filtered */
    filter?: InputMaybe<FacetFilterParameter>;
    /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
    filterOperator?: InputMaybe<LogicalOperator>;
    /** Skips the first n results, for use in pagination */
    skip?: InputMaybe<Scalars['Int']>;
    /** Specifies which properties to sort the results by */
    sort?: InputMaybe<FacetSortParameter>;
    /** Takes n results, for use in pagination */
    take?: InputMaybe<Scalars['Int']>;
};
export declare type FacetSortParameter = {
    code?: InputMaybe<SortOrder>;
    createdAt?: InputMaybe<SortOrder>;
    id?: InputMaybe<SortOrder>;
    name?: InputMaybe<SortOrder>;
    updatedAt?: InputMaybe<SortOrder>;
};
export declare type FacetTranslation = {
    __typename?: 'FacetTranslation';
    createdAt: Scalars['DateTime'];
    id: Scalars['ID'];
    languageCode: LanguageCode;
    name: Scalars['String'];
    updatedAt: Scalars['DateTime'];
};
export declare type FacetTranslationInput = {
    customFields?: InputMaybe<Scalars['JSON']>;
    id?: InputMaybe<Scalars['ID']>;
    languageCode: LanguageCode;
    name?: InputMaybe<Scalars['String']>;
};
export declare type FacetValue = Node & {
    __typename?: 'FacetValue';
    code: Scalars['String'];
    createdAt: Scalars['DateTime'];
    customFields?: Maybe<Scalars['JSON']>;