@soppiya/app-bridge 1.0.0

package/dist/shared/graphql/graphql.d.ts

@@ -0,0 +1,3881 @@
+import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    /** 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: {
+        input: unknown;
+        output: unknown;
+    };
+    /** The `Upload` scalar type represents a file upload. */
+    Upload: {
+        input: unknown;
+        output: unknown;
+    };
+};
+export declare enum AccountEmailIntent {
+    primary = "primary",
+    secondary = "secondary"
+}
+export declare enum AccountEmailUpdateActionIntent {
+    change = "change",
+    remove = "remove"
+}
+export type AccountSecurity = {
+    __typename: 'AccountSecurity';
+    is_password_set?: Maybe<Scalars['Boolean']['output']>;
+    two_factor_authentication?: Maybe<TwoFactorAuthentication>;
+};
+export type AddCollection = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    match_type?: InputMaybe<CollectionMatchType>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    products?: InputMaybe<Array<Scalars['ID']['input']>>;
+    rules?: InputMaybe<Array<InputMaybe<CollectionRuleInput>>>;
+    sort_by?: InputMaybe<CollectionSortBy>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    type: CollectionType;
+};
+export type AddCollectionProduct = {
+    collection: Scalars['ID']['input'];
+    product: Scalars['ID']['input'];
+};
+export type AddDomain = {
+    name: Scalars['String']['input'];
+    records?: InputMaybe<Array<DomainRecordInput>>;
+};
+export type AddInventory = {
+    available?: InputMaybe<Scalars['Int']['input']>;
+    committed?: InputMaybe<Scalars['Int']['input']>;
+    damaged?: InputMaybe<Scalars['Int']['input']>;
+    incoming?: InputMaybe<Scalars['Int']['input']>;
+    location: Scalars['ID']['input'];
+    quality_control?: InputMaybe<Scalars['Int']['input']>;
+    reserved?: InputMaybe<Scalars['Int']['input']>;
+    safety_stock?: InputMaybe<Scalars['Int']['input']>;
+    variant: Scalars['ID']['input'];
+};
+export type AddMarket = {
+    countries: Array<Scalars['ID']['input']>;
+    currency: Scalars['ID']['input'];
+    domain?: InputMaybe<Scalars['ID']['input']>;
+    is_active?: InputMaybe<Scalars['Boolean']['input']>;
+    language?: InputMaybe<Scalars['ID']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    name: Scalars['String']['input'];
+};
+export type AddMarketVariant = {
+    compare_at_price?: InputMaybe<Scalars['Float']['input']>;
+    is_fixed_price?: InputMaybe<Scalars['Boolean']['input']>;
+    is_tax_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    market: Scalars['ID']['input'];
+    price: Scalars['Float']['input'];
+    price_breaks?: InputMaybe<Array<InputMaybe<PriceBreakInput>>>;
+    quantity_rule?: InputMaybe<QuantityRuleInput>;
+    sell_when_out_of_stock?: InputMaybe<Scalars['Boolean']['input']>;
+    sku?: InputMaybe<Scalars['String']['input']>;
+    track_inventory?: InputMaybe<Scalars['Boolean']['input']>;
+    use_wholesale?: InputMaybe<Scalars['Boolean']['input']>;
+    variant: Scalars['ID']['input'];
+};
+export type AddPreset = {
+    data: Scalars['String']['input'];
+    title: Scalars['String']['input'];
+    type: PresetType;
+};
+export type AddProduct = {
+    category?: InputMaybe<Scalars['ID']['input']>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    media?: InputMaybe<Array<Scalars['ID']['input']>>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<MetafieldInput>>;
+    option1?: InputMaybe<Scalars['String']['input']>;
+    option2?: InputMaybe<Scalars['String']['input']>;
+    option3?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<ProductStatus>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title: Scalars['String']['input'];
+    type?: InputMaybe<Scalars['String']['input']>;
+    variants?: InputMaybe<Array<VariantInput>>;
+    vendor?: InputMaybe<Scalars['String']['input']>;
+};
+export type AddRedirect = {
+    from: Scalars['String']['input'];
+    to: Scalars['String']['input'];
+};
+export type AddStaff = {
+    app_permission?: InputMaybe<StaffAppPermission>;
+    email: Scalars['String']['input'];
+    limited_apps?: InputMaybe<Array<Scalars['ID']['input']>>;
+    permissions?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export type AddVariant = {
+    MarketVariants?: InputMaybe<Array<InputMaybe<MarketVariantInput>>>;
+    barcode?: InputMaybe<Scalars['String']['input']>;
+    cost_per_item?: InputMaybe<Scalars['Float']['input']>;
+    country_of_origin?: InputMaybe<Scalars['ID']['input']>;
+    height?: InputMaybe<Scalars['Float']['input']>;
+    hs_code?: InputMaybe<Scalars['ID']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    inventories?: InputMaybe<Array<InputMaybe<InventoryInput>>>;
+    is_shipping_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    length?: InputMaybe<Scalars['Float']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    option1?: InputMaybe<Scalars['String']['input']>;
+    option2?: InputMaybe<Scalars['String']['input']>;
+    option3?: InputMaybe<Scalars['String']['input']>;
+    product: Scalars['ID']['input'];
+    shipping_profile?: InputMaybe<Scalars['ID']['input']>;
+    status?: InputMaybe<VariantStatus>;
+    weight?: InputMaybe<Scalars['Float']['input']>;
+    width?: InputMaybe<Scalars['Float']['input']>;
+};
+export type Address = {
+    __typename: 'Address';
+    address1?: Maybe<Scalars['String']['output']>;
+    address2?: Maybe<Scalars['String']['output']>;
+    city?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<_Country>;
+    email?: Maybe<Email>;
+    name?: Maybe<Scalars['String']['output']>;
+    phone?: Maybe<Phone>;
+    postal_code?: Maybe<Scalars['String']['output']>;
+};
+export type AddressInput = {
+    address1?: InputMaybe<Scalars['String']['input']>;
+    address2?: InputMaybe<Scalars['String']['input']>;
+    city?: InputMaybe<Scalars['String']['input']>;
+    country?: InputMaybe<Scalars['ID']['input']>;
+    email?: InputMaybe<EmailInput>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    phone?: InputMaybe<PhoneInput>;
+    postal_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type App = {
+    __typename: 'App';
+    _id?: Maybe<Scalars['ID']['output']>;
+    app?: Maybe<_App>;
+    is_pinned?: Maybe<Scalars['Boolean']['output']>;
+    store?: Maybe<Store>;
+};
+export type AppConnection = {
+    __typename: 'AppConnection';
+    edges?: Maybe<Array<Maybe<AppEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type AppEdge = {
+    __typename: 'AppEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<App>;
+};
+export type AppFilterKeys = {
+    apps?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    is_pinned?: InputMaybe<Scalars['Boolean']['input']>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum AppSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt"
+}
+export type Article = {
+    __typename: 'Article';
+    _id?: Maybe<Scalars['ID']['output']>;
+    author?: Maybe<User>;
+    blog?: Maybe<Blog>;
+    comment_permission?: Maybe<Scalars['String']['output']>;
+    content?: Maybe<Scalars['String']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    excerpt?: Maybe<Scalars['String']['output']>;
+    handle?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<Media>;
+    meta_description?: Maybe<Scalars['String']['output']>;
+    meta_tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    meta_title?: Maybe<Scalars['String']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    status?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    template?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export declare enum ArticleCommentPermission {
+    all = "all",
+    moderate = "moderate",
+    none = "none"
+}
+export type ArticleConnection = {
+    __typename: 'ArticleConnection';
+    edges?: Maybe<Array<Maybe<ArticleEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type ArticleEdge = {
+    __typename: 'ArticleEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Article>;
+};
+export type ArticleFilterKeys = {
+    authors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    blogs?: InputMaybe<Array<Scalars['ID']['input']>>;
+    comment_permissions?: InputMaybe<Array<ArticleCommentPermission>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    statuses?: InputMaybe<Array<ArticleStatus>>;
+    templates?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum ArticleSortKeys {
+    _id = "_id",
+    blog = "blog",
+    createdAt = "createdAt",
+    status = "status",
+    title = "title",
+    updatedAt = "updatedAt"
+}
+export declare enum ArticleStatus {
+    active = "active",
+    draft = "draft"
+}
+export type Authenticator = {
+    __typename: 'Authenticator';
+    is_enabled?: Maybe<Scalars['Boolean']['output']>;
+};
+export type Blog = {
+    __typename: 'Blog';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    handle?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<Media>;
+    meta_description?: Maybe<Scalars['String']['output']>;
+    meta_tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    meta_title?: Maybe<Scalars['String']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    store?: Maybe<Store>;
+    template?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type BlogConnection = {
+    __typename: 'BlogConnection';
+    edges?: Maybe<Array<Maybe<BlogEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type BlogEdge = {
+    __typename: 'BlogEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Blog>;
+};
+export type BlogFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    exclude_cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum BlogSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    title = "title",
+    updatedAt = "updatedAt"
+}
+export type Brand = {
+    __typename: 'Brand';
+    cover_image?: Maybe<Media>;
+    default_logo?: Maybe<Media>;
+    facebook?: Maybe<Scalars['String']['output']>;
+    instagram?: Maybe<Scalars['String']['output']>;
+    pinterest?: Maybe<Scalars['String']['output']>;
+    primary_color?: Maybe<Scalars['String']['output']>;
+    secondary_color?: Maybe<Scalars['String']['output']>;
+    short_description?: Maybe<Scalars['String']['output']>;
+    slogan?: Maybe<Scalars['String']['output']>;
+    snapchat?: Maybe<Scalars['String']['output']>;
+    square_logo?: Maybe<Media>;
+    store?: Maybe<Store>;
+    tiktok?: Maybe<Scalars['String']['output']>;
+    tumblr?: Maybe<Scalars['String']['output']>;
+    twitter?: Maybe<Scalars['String']['output']>;
+    vimeo?: Maybe<Scalars['String']['output']>;
+    whatsapp?: Maybe<Scalars['String']['output']>;
+    youtube?: Maybe<Scalars['String']['output']>;
+};
+export type Checkout = {
+    __typename: 'Checkout';
+    address2_requirement?: Maybe<CheckoutExcludeRequiredOptional>;
+    auto_archive_order?: Maybe<Scalars['Boolean']['output']>;
+    auto_fulfill_high_risk?: Maybe<Scalars['Boolean']['output']>;
+    auto_fulfill_notify_customer?: Maybe<Scalars['Boolean']['output']>;
+    auto_fulfillment?: Maybe<CheckoutAutoFulfillment>;
+    auto_select_email_subscription?: Maybe<Scalars['Boolean']['output']>;
+    company_requirement?: Maybe<CheckoutExcludeRequiredOptional>;
+    contact_method?: Maybe<CheckoutContactMethod>;
+    custom_script?: Maybe<Scalars['String']['output']>;
+    enable_tipping?: Maybe<Scalars['Boolean']['output']>;
+    hide_tipping?: Maybe<Scalars['Boolean']['output']>;
+    is_login_required?: Maybe<Scalars['Boolean']['output']>;
+    name_requirement?: Maybe<CheckoutNameRequirement>;
+    offer_address_suggestion?: Maybe<Scalars['Boolean']['output']>;
+    self_serve_return?: Maybe<Scalars['Boolean']['output']>;
+    shipping_phone_requirement?: Maybe<CheckoutExcludeRequiredOptional>;
+    show_email_subscription?: Maybe<Scalars['Boolean']['output']>;
+    show_login_link?: Maybe<Scalars['Boolean']['output']>;
+    show_sms_subscription?: Maybe<Scalars['Boolean']['output']>;
+    store?: Maybe<Store>;
+    tipping_preset_1?: Maybe<Scalars['Float']['output']>;
+    tipping_preset_2?: Maybe<Scalars['Float']['output']>;
+    tipping_preset_3?: Maybe<Scalars['Float']['output']>;
+    use_shipping_as_billing?: Maybe<Scalars['Boolean']['output']>;
+};
+export declare enum CheckoutAutoFulfillment {
+    all = "all",
+    gift_cards = "gift_cards",
+    none = "none"
+}
+export declare enum CheckoutContactMethod {
+    email = "email",
+    phone_or_email = "phone_or_email"
+}
+export declare enum CheckoutExcludeRequiredOptional {
+    exclude = "exclude",
+    optional = "optional",
+    required = "required"
+}
+export declare enum CheckoutNameRequirement {
+    full_name = "full_name",
+    last_name = "last_name"
+}
+export type Collection = {
+    __typename: 'Collection';
+    _id?: Maybe<Scalars['ID']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    handle?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<Media>;
+    match_type?: Maybe<CollectionMatchType>;
+    meta_description?: Maybe<Scalars['String']['output']>;
+    meta_tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    meta_title?: Maybe<Scalars['String']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    rules?: Maybe<Array<Maybe<CollectionRule>>>;
+    sort_by?: Maybe<CollectionSortBy>;
+    store?: Maybe<Store>;
+    template?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    type: CollectionType;
+};
+export type CollectionConnection = {
+    __typename: 'CollectionConnection';
+    edges?: Maybe<Array<Maybe<CollectionEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type CollectionEdge = {
+    __typename: 'CollectionEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Collection>;
+};
+export type CollectionFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    templates?: InputMaybe<Array<Scalars['String']['input']>>;
+    types?: InputMaybe<Array<CollectionType>>;
+};
+export declare enum CollectionMatchType {
+    match_all = "match_all",
+    match_any = "match_any"
+}
+export type CollectionProduct = {
+    __typename: 'CollectionProduct';
+    _id?: Maybe<Scalars['ID']['output']>;
+    collection?: Maybe<Collection>;
+    index?: Maybe<Scalars['Int']['output']>;
+    product?: Maybe<Product>;
+    store?: Maybe<Store>;
+};
+export type CollectionProductConnection = {
+    __typename: 'CollectionProductConnection';
+    edges?: Maybe<Array<Maybe<CollectionProductEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type CollectionProductEdge = {
+    __typename: 'CollectionProductEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<CollectionProduct>;
+};
+export type CollectionProductFilterKeys = {
+    collections?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    products?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export declare enum CollectionProductSortkey {
+    _id = "_id",
+    collection = "collection",
+    createdAt = "createdAt",
+    index = "index",
+    product = "product",
+    updatedAt = "updatedAt"
+}
+export type CollectionRule = {
+    __typename: 'CollectionRule';
+    data?: Maybe<CollectionRuleField>;
+    relation?: Maybe<CollectionRuleRelation>;
+    value?: Maybe<Scalars['String']['output']>;
+};
+export declare enum CollectionRuleField {
+    available = "available",
+    committed = "committed",
+    createdAt = "createdAt",
+    damaged = "damaged",
+    description = "description",
+    handle = "handle",
+    incoming = "incoming",
+    meta_description = "meta_description",
+    meta_tag = "meta_tag",
+    meta_title = "meta_title",
+    on_hand = "on_hand",
+    option1 = "option1",
+    option2 = "option2",
+    option3 = "option3",
+    price = "price",
+    quality_control = "quality_control",
+    reserved = "reserved",
+    safety_stock = "safety_stock",
+    tag = "tag",
+    template = "template",
+    title = "title",
+    type = "type",
+    updatedAt = "updatedAt",
+    vendor = "vendor"
+}
+export type CollectionRuleInput = {
+    field: CollectionRuleField;
+    relation: CollectionRuleRelation;
+    value: Scalars['String']['input'];
+};
+export declare enum CollectionRuleRelation {
+    contains = "contains",
+    does_not_contain = "does_not_contain",
+    ends_with = "ends_with",
+    is_empty = "is_empty",
+    is_equal_to = "is_equal_to",
+    is_greater_than = "is_greater_than",
+    is_less_than = "is_less_than",
+    is_not_empty = "is_not_empty",
+    is_not_equal_to = "is_not_equal_to",
+    starts_with = "starts_with"
+}
+export declare enum CollectionSortBy {
+    _id = "_id",
+    available = "available",
+    category = "category",
+    committed = "committed",
+    createdAt = "createdAt",
+    damaged = "damaged",
+    incoming = "incoming",
+    manual = "manual",
+    on_hand = "on_hand",
+    option1 = "option1",
+    option2 = "option2",
+    option3 = "option3",
+    price_max = "price_max",
+    price_min = "price_min",
+    quality_control = "quality_control",
+    reserved = "reserved",
+    safety_stock = "safety_stock",
+    status = "status",
+    tags = "tags",
+    title = "title",
+    type = "type",
+    updatedAt = "updatedAt",
+    vendor = "vendor"
+}
+export declare enum CollectionSortKey {
+    _id = "_id",
+    createdAt = "createdAt",
+    handle = "handle",
+    meta_title = "meta_title",
+    template = "template",
+    title = "title",
+    type = "type",
+    updatedAt = "updatedAt"
+}
+export declare enum CollectionType {
+    automated = "automated",
+    manual = "manual"
+}
+export type Device = {
+    __typename: 'Device';
+    _id?: Maybe<Scalars['ID']['output']>;
+    browser_name?: Maybe<Scalars['String']['output']>;
+    isThisDevice?: Maybe<Scalars['Boolean']['output']>;
+    last_session?: Maybe<Session>;
+    os_name?: Maybe<Scalars['String']['output']>;
+    session_history?: Maybe<UserSessionConnection>;
+};
+export type DeviceSession_HistoryArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<UserSessionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<UserSessionSortKeys>;
+};
+export type Domain = {
+    __typename: 'Domain';
+    _id?: Maybe<Scalars['ID']['output']>;
+    is_primary?: Maybe<Scalars['Boolean']['output']>;
+    is_tld?: Maybe<Scalars['Boolean']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    records?: Maybe<Array<Maybe<DomainRecord>>>;
+    store?: Maybe<Store>;
+};
+export type DomainConnection = {
+    __typename: 'DomainConnection';
+    edges?: Maybe<Array<Maybe<DomainEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type DomainEdge = {
+    __typename: 'DomainEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Domain>;
+};
+export type DomainFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    is_primary?: InputMaybe<Scalars['Boolean']['input']>;
+    is_tld?: InputMaybe<Scalars['Boolean']['input']>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type DomainRecord = {
+    __typename: 'DomainRecord';
+    _id?: Maybe<Scalars['ID']['output']>;
+    address?: Maybe<Scalars['String']['output']>;
+    admin?: Maybe<Scalars['String']['output']>;
+    data?: Maybe<Scalars['String']['output']>;
+    domain?: Maybe<Scalars['String']['output']>;
+    exchange?: Maybe<Scalars['String']['output']>;
+    expiration?: Maybe<Scalars['Int']['output']>;
+    host?: Maybe<Scalars['String']['output']>;
+    minimum?: Maybe<Scalars['Int']['output']>;
+    ns?: Maybe<Scalars['String']['output']>;
+    port?: Maybe<Scalars['Int']['output']>;
+    primary?: Maybe<Scalars['String']['output']>;
+    priority?: Maybe<Scalars['Int']['output']>;
+    refresh?: Maybe<Scalars['Int']['output']>;
+    retry?: Maybe<Scalars['Int']['output']>;
+    serial?: Maybe<Scalars['Int']['output']>;
+    target?: Maybe<Scalars['String']['output']>;
+    ttl?: Maybe<Scalars['Int']['output']>;
+    type?: Maybe<DomainRecordType>;
+    weight?: Maybe<Scalars['Int']['output']>;
+};
+export type DomainRecordInput = {
+    address?: InputMaybe<Scalars['String']['input']>;
+    admin?: InputMaybe<Scalars['String']['input']>;
+    data?: InputMaybe<Scalars['String']['input']>;
+    domain?: InputMaybe<Scalars['String']['input']>;
+    exchange?: InputMaybe<Scalars['String']['input']>;
+    expiration?: InputMaybe<Scalars['Int']['input']>;
+    host: Scalars['String']['input'];
+    minimum?: InputMaybe<Scalars['Int']['input']>;
+    ns?: InputMaybe<Scalars['String']['input']>;
+    port?: InputMaybe<Scalars['Int']['input']>;
+    primary?: InputMaybe<Scalars['String']['input']>;
+    priority?: InputMaybe<Scalars['Int']['input']>;
+    refresh?: InputMaybe<Scalars['Int']['input']>;
+    retry?: InputMaybe<Scalars['Int']['input']>;
+    serial?: InputMaybe<Scalars['Int']['input']>;
+    target?: InputMaybe<Scalars['String']['input']>;
+    ttl: Scalars['Int']['input'];
+    type: DomainRecordType;
+    weight?: InputMaybe<Scalars['Int']['input']>;
+};
+export declare enum DomainRecordType {
+    A = "A",
+    AAAA = "AAAA",
+    CNAME = "CNAME",
+    MX = "MX",
+    NS = "NS",
+    PTR = "PTR",
+    SOA = "SOA",
+    SRV = "SRV",
+    TXT = "TXT"
+}
+export declare enum DomainSortkeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    is_primary = "is_primary",
+    is_tld = "is_tld",
+    name = "name",
+    updatedAt = "updatedAt"
+}
+export type EditCollection = {
+    cursor: Scalars['ID']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    match_type?: InputMaybe<CollectionMatchType>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    rules?: InputMaybe<Array<InputMaybe<CollectionRuleInput>>>;
+    sort_by?: InputMaybe<CollectionSortBy>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type EditCollectionProduct = {
+    cursor: Scalars['ID']['input'];
+    index: Scalars['Int']['input'];
+};
+export type EditDomain = {
+    cursor: Scalars['ID']['input'];
+    is_primary?: InputMaybe<Scalars['Boolean']['input']>;
+    records?: InputMaybe<Array<DomainRecordInput>>;
+};
+export type EditInventory = {
+    available?: InputMaybe<Scalars['Int']['input']>;
+    committed?: InputMaybe<Scalars['Int']['input']>;
+    cursor: Scalars['ID']['input'];
+    damaged?: InputMaybe<Scalars['Int']['input']>;
+    incoming?: InputMaybe<Scalars['Int']['input']>;
+    quality_control?: InputMaybe<Scalars['Int']['input']>;
+    reserved?: InputMaybe<Scalars['Int']['input']>;
+    safety_stock?: InputMaybe<Scalars['Int']['input']>;
+};
+export type EditMarket = {
+    countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    currency?: InputMaybe<Scalars['ID']['input']>;
+    cursor: Scalars['ID']['input'];
+    domain?: InputMaybe<Scalars['ID']['input']>;
+    is_active?: InputMaybe<Scalars['Boolean']['input']>;
+    is_primary?: InputMaybe<Scalars['Boolean']['input']>;
+    language?: InputMaybe<Scalars['ID']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    price_adjustment?: InputMaybe<Scalars['Float']['input']>;
+};
+export type EditMarketVariant = {
+    compare_at_price?: InputMaybe<Scalars['Float']['input']>;
+    cursor: Scalars['ID']['input'];
+    is_fixed_price?: InputMaybe<Scalars['Boolean']['input']>;
+    is_tax_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    price?: InputMaybe<Scalars['Float']['input']>;
+    price_breaks?: InputMaybe<Array<InputMaybe<PriceBreakInput>>>;
+    quantity_rule?: InputMaybe<QuantityRuleInput>;
+    sell_when_out_of_stock?: InputMaybe<Scalars['Boolean']['input']>;
+    sku?: InputMaybe<Scalars['String']['input']>;
+    track_inventory?: InputMaybe<Scalars['Boolean']['input']>;
+    use_wholesale?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type EditPolicy = {
+    contact_information?: InputMaybe<Scalars['String']['input']>;
+    privacy_policy?: InputMaybe<Scalars['String']['input']>;
+    return_policy?: InputMaybe<Scalars['String']['input']>;
+    return_restocking_fee?: InputMaybe<Scalars['Float']['input']>;
+    return_shipping_charge?: InputMaybe<Scalars['Float']['input']>;
+    return_status?: InputMaybe<Scalars['Boolean']['input']>;
+    return_window?: InputMaybe<Scalars['Int']['input']>;
+    sale_collections?: InputMaybe<Array<Scalars['ID']['input']>>;
+    sale_products?: InputMaybe<Array<Scalars['ID']['input']>>;
+    shipping_plicy?: InputMaybe<Scalars['String']['input']>;
+    terms_of_service?: InputMaybe<Scalars['String']['input']>;
+};
+export type EditPreset = {
+    cursor: Scalars['ID']['input'];
+    data?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type EditProduct = {
+    category?: InputMaybe<Scalars['ID']['input']>;
+    cursor: Scalars['ID']['input'];
+    description?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    media?: InputMaybe<Array<Scalars['ID']['input']>>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<MetafieldInput>>;
+    option1?: InputMaybe<Scalars['String']['input']>;
+    option2?: InputMaybe<Scalars['String']['input']>;
+    option3?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<ProductStatus>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<Scalars['String']['input']>;
+    vendor?: InputMaybe<Scalars['String']['input']>;
+};
+export type EditRedirect = {
+    cursor: Scalars['ID']['input'];
+    from?: InputMaybe<Scalars['String']['input']>;
+    to?: InputMaybe<Scalars['String']['input']>;
+};
+export type EditStaff = {
+    app_permission?: InputMaybe<StaffAppPermission>;
+    cursor: Scalars['ID']['input'];
+    limited_apps?: InputMaybe<Array<Scalars['ID']['input']>>;
+    permissions?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export type EditStore = {
+    address?: InputMaybe<AddressInput>;
+    length_unit?: InputMaybe<StoreLengthUnit>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    order_prefix?: InputMaybe<Scalars['String']['input']>;
+    order_suffix?: InputMaybe<Scalars['String']['input']>;
+    timezone?: InputMaybe<Scalars['ID']['input']>;
+    weight_unit?: InputMaybe<StoreWeightUnit>;
+};
+export type EditVariant = {
+    barcode?: InputMaybe<Scalars['String']['input']>;
+    cost_per_item?: InputMaybe<Scalars['Float']['input']>;
+    country_of_origin?: InputMaybe<Scalars['ID']['input']>;
+    cursor: Scalars['ID']['input'];
+    height?: InputMaybe<Scalars['Float']['input']>;
+    hs_code?: InputMaybe<Scalars['ID']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    is_shipping_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    length?: InputMaybe<Scalars['Float']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    option1?: InputMaybe<Scalars['String']['input']>;
+    option2?: InputMaybe<Scalars['String']['input']>;
+    option3?: InputMaybe<Scalars['String']['input']>;
+    shipping_profile?: InputMaybe<Scalars['ID']['input']>;
+    status?: InputMaybe<VariantStatus>;
+    weight?: InputMaybe<Scalars['Float']['input']>;
+    width?: InputMaybe<Scalars['Float']['input']>;
+};
+export type Email = {
+    __typename: 'Email';
+    address?: Maybe<Scalars['String']['output']>;
+    has_subscribed?: Maybe<Scalars['Boolean']['output']>;
+    has_unsubscribed?: Maybe<Scalars['Boolean']['output']>;
+    is_verified?: Maybe<Scalars['Boolean']['output']>;
+};
+export type EmailInput = {
+    address: Scalars['String']['input'];
+    has_subscribed?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type Inventory = {
+    __typename: 'Inventory';
+    _id?: Maybe<Scalars['ID']['output']>;
+    available?: Maybe<Scalars['Int']['output']>;
+    committed?: Maybe<Scalars['Int']['output']>;
+    damaged?: Maybe<Scalars['Int']['output']>;
+    incoming?: Maybe<Scalars['Int']['output']>;
+    location?: Maybe<Location>;
+    on_hand?: Maybe<Scalars['Int']['output']>;
+    product?: Maybe<Product>;
+    quality_control?: Maybe<Scalars['Int']['output']>;
+    reserved?: Maybe<Scalars['Int']['output']>;
+    safety_stock?: Maybe<Scalars['Int']['output']>;
+    store?: Maybe<Store>;
+    variant?: Maybe<Variant>;
+};
+export type InventoryConnection = {
+    __typename: 'InventoryConnection';
+    edges?: Maybe<Array<Maybe<InventoryEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type InventoryEdge = {
+    __typename: 'InventoryEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Inventory>;
+};
+export type InventoryFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    locations?: InputMaybe<Array<Scalars['ID']['input']>>;
+    products?: InputMaybe<Array<Scalars['ID']['input']>>;
+    variants?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type InventoryInput = {
+    available?: InputMaybe<Scalars['Int']['input']>;
+    committed?: InputMaybe<Scalars['Int']['input']>;
+    damaged?: InputMaybe<Scalars['Int']['input']>;
+    incoming?: InputMaybe<Scalars['Int']['input']>;
+    location: Scalars['ID']['input'];
+    quality_control?: InputMaybe<Scalars['Int']['input']>;
+    reserved?: InputMaybe<Scalars['Int']['input']>;
+    safety_stock?: InputMaybe<Scalars['Int']['input']>;
+};
+export declare enum InventorySortKeys {
+    _id = "_id",
+    available = "available",
+    committed = "committed",
+    createdAt = "createdAt",
+    damaged = "damaged",
+    incoming = "incoming",
+    on_hand = "on_hand",
+    quality_control = "quality_control",
+    reserved = "reserved",
+    safety_stock = "safety_stock",
+    updatedAt = "updatedAt"
+}
+export type Linklist = {
+    __typename: 'Linklist';
+    _id?: Maybe<Scalars['ID']['output']>;
+    handle?: Maybe<Scalars['String']['output']>;
+    links?: Maybe<Array<Maybe<LinklistLayer1>>>;
+    store?: Maybe<Store>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type LinklistConnection = {
+    __typename: 'LinklistConnection';
+    edges?: Maybe<Array<Maybe<LinklistEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type LinklistEdge = {
+    __typename: 'LinklistEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Linklist>;
+};
+export type LinklistFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type LinklistLayer1 = {
+    __typename: 'LinklistLayer1';
+    _id?: Maybe<Scalars['ID']['output']>;
+    links?: Maybe<Array<Maybe<LinklistLayer2>>>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type LinklistLayer1Input = {
+    links?: InputMaybe<Array<InputMaybe<LinklistLayer2Input>>>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    type: LinklistType;
+    url?: InputMaybe<Scalars['String']['input']>;
+};
+export type LinklistLayer2 = {
+    __typename: 'LinklistLayer2';
+    _id?: Maybe<Scalars['ID']['output']>;
+    links?: Maybe<Array<Maybe<LinklistLayer3>>>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type LinklistLayer2Input = {
+    links?: InputMaybe<Array<InputMaybe<LinklistLayer3Input>>>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    type: LinklistType;
+    url?: InputMaybe<Scalars['String']['input']>;
+};
+export type LinklistLayer3 = {
+    __typename: 'LinklistLayer3';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type LinklistLayer3Input = {
+    title?: InputMaybe<Scalars['String']['input']>;
+    type: LinklistType;
+    url?: InputMaybe<Scalars['String']['input']>;
+};
+export declare enum LinklistSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    title = "title",
+    updatedAt = "updatedAt"
+}
+export declare enum LinklistType {
+    article = "article",
+    blog = "blog",
+    catalog = "catalog",
+    collection = "collection",
+    collections = "collections",
+    frontpage = "frontpage",
+    http = "http",
+    metaobject = "metaobject",
+    page = "page",
+    policy = "policy",
+    product = "product",
+    search = "search"
+}
+export type Location = {
+    __typename: 'Location';
+    _id?: Maybe<Scalars['ID']['output']>;
+    address1?: Maybe<Scalars['String']['output']>;
+    address2?: Maybe<Scalars['String']['output']>;
+    city?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<_Country>;
+    email?: Maybe<Email>;
+    fulfill_online_orders?: Maybe<Scalars['Boolean']['output']>;
+    is_default?: Maybe<Scalars['Boolean']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    name?: Maybe<Scalars['String']['output']>;
+    phone?: Maybe<Phone>;
+    postal_code?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+};
+export type LocationConnection = {
+    __typename: 'LocationConnection';
+    edges?: Maybe<Array<Maybe<LocationEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type LocationEdge = {
+    __typename: 'LocationEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Location>;
+};
+export type LocationFilterKeys = {
+    cities?: InputMaybe<Array<Scalars['String']['input']>>;
+    countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    fulfill_online_orders?: InputMaybe<Scalars['Boolean']['input']>;
+    is_default?: InputMaybe<Scalars['Boolean']['input']>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    postal_codes?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum LocationSortKeys {
+    _id = "_id",
+    address1 = "address1",
+    address2 = "address2",
+    city = "city",
+    country = "country",
+    createdAt = "createdAt",
+    is_default = "is_default",
+    name = "name",
+    postal_code = "postal_code",
+    updatedAt = "updatedAt"
+}
+export declare enum LoginMethod {
+    email = "email",
+    google = "google",
+    passkey = "passkey"
+}
+export type Market = {
+    __typename: 'Market';
+    _id?: Maybe<Scalars['ID']['output']>;
+    countries?: Maybe<Array<Maybe<_Country>>>;
+    currency?: Maybe<_Currency>;
+    domain?: Maybe<Domain>;
+    is_active?: Maybe<Scalars['Boolean']['output']>;
+    is_primary?: Maybe<Scalars['Boolean']['output']>;
+    language?: Maybe<_Language>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    name?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    variants?: Maybe<MarketVariantConnection>;
+};
+export type MarketVariantsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<MarketVariantFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MarketVariantSortKeys>;
+};
+export type MarketConnection = {
+    __typename: 'MarketConnection';
+    edges?: Maybe<Array<Maybe<MarketEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type MarketCountry = {
+    __typename: 'MarketCountry';
+    country?: Maybe<_Country>;
+    market?: Maybe<Market>;
+};
+export type MarketEdge = {
+    __typename: 'MarketEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Market>;
+};
+export type MarketFilterKeys = {
+    countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    currencies?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    domains?: InputMaybe<Array<Scalars['ID']['input']>>;
+    is_active?: InputMaybe<Scalars['Boolean']['input']>;
+    is_primary?: InputMaybe<Scalars['Boolean']['input']>;
+    languages?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum MarketSortKeys {
+    _id = "_id",
+    currency = "currency",
+    domain = "domain",
+    is_active = "is_active",
+    is_primary = "is_primary",
+    language = "language",
+    name = "name",
+    price_adjustment = "price_adjustment"
+}
+export type MarketVariant = {
+    __typename: 'MarketVariant';
+    _id?: Maybe<Scalars['ID']['output']>;
+    compare_at_price?: Maybe<Scalars['Float']['output']>;
+    is_fixed_price?: Maybe<Scalars['Boolean']['output']>;
+    is_tax_applicable?: Maybe<Scalars['Boolean']['output']>;
+    market?: Maybe<Market>;
+    price?: Maybe<Scalars['Float']['output']>;
+    price_breaks?: Maybe<Array<Maybe<PriceBreak>>>;
+    product?: Maybe<Product>;
+    quantity_rule?: Maybe<QuantityRule>;
+    sell_when_out_of_stock?: Maybe<Scalars['Boolean']['output']>;
+    sku?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    track_inventory?: Maybe<Scalars['Boolean']['output']>;
+    use_wholesale?: Maybe<Scalars['Boolean']['output']>;
+    variant?: Maybe<Variant>;
+};
+export type MarketVariantConnection = {
+    __typename: 'MarketVariantConnection';
+    edges?: Maybe<Array<Maybe<MarketVariantEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type MarketVariantEdge = {
+    __typename: 'MarketVariantEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<MarketVariant>;
+};
+export type MarketVariantFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    markets?: InputMaybe<Array<Scalars['ID']['input']>>;
+    variants?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type MarketVariantInput = {
+    compare_at_price?: InputMaybe<Scalars['Float']['input']>;
+    is_fixed_price?: InputMaybe<Scalars['Boolean']['input']>;
+    is_tax_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    market: Scalars['ID']['input'];
+    price: Scalars['Float']['input'];
+    price_breaks?: InputMaybe<Array<InputMaybe<PriceBreakInput>>>;
+    quantity_rule?: InputMaybe<QuantityRuleInput>;
+    sell_when_out_of_stock?: InputMaybe<Scalars['Boolean']['input']>;
+    sku?: InputMaybe<Scalars['String']['input']>;
+    track_inventory?: InputMaybe<Scalars['Boolean']['input']>;
+    use_wholesale?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export declare enum MarketVariantSortKeys {
+    _id = "_id",
+    compare_at_price = "compare_at_price",
+    is_fixed_price = "is_fixed_price",
+    is_tax_applicable = "is_tax_applicable",
+    market = "market",
+    price = "price",
+    product = "product",
+    sell_when_out_of_stock = "sell_when_out_of_stock",
+    sku = "sku",
+    track_inventory = "track_inventory",
+    use_wholesale = "use_wholesale",
+    variant = "variant"
+}
+export type Media = {
+    __typename: 'Media';
+    _id?: Maybe<Scalars['ID']['output']>;
+    file_name?: Maybe<Scalars['String']['output']>;
+    mimetype?: Maybe<Scalars['String']['output']>;
+    size?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    type?: Maybe<MediaType>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type MediaConnection = {
+    __typename: 'MediaConnection';
+    edges?: Maybe<Array<Maybe<MediaEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type MediaEdge = {
+    __typename: 'MediaEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Media>;
+};
+export type MediaFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    types?: InputMaybe<Array<MediaType>>;
+};
+export declare enum MediaSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    file_name = "file_name",
+    mimetype = "mimetype",
+    type = "type"
+}
+export declare enum MediaType {
+    audio = "audio",
+    file = "file",
+    image = "image",
+    video = "video"
+}
+export type Metafield = {
+    __typename: 'Metafield';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    entry?: Maybe<MetafieldEntryType>;
+    is_public?: Maybe<Scalars['Boolean']['output']>;
+    key?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    scope?: Maybe<MetafieldScope>;
+    store?: Maybe<Store>;
+    type?: Maybe<MetafieldType>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type MetafieldConnection = {
+    __typename: 'MetafieldConnection';
+    edges?: Maybe<Array<Maybe<MetafieldEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type MetafieldData = {
+    __typename: 'MetafieldData';
+    _id?: Maybe<Scalars['ID']['output']>;
+    metafield?: Maybe<Metafield>;
+    value?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type MetafieldEdge = {
+    __typename: 'MetafieldEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Metafield>;
+};
+export declare enum MetafieldEntryType {
+    multiple = "multiple",
+    single = "single"
+}
+export type MetafieldFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    scopes?: InputMaybe<Array<MetafieldScope>>;
+    types?: InputMaybe<Array<MetafieldType>>;
+};
+export type MetafieldInput = {
+    metafield: Scalars['ID']['input'];
+    value?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export declare enum MetafieldScope {
+    article = "article",
+    blog = "blog",
+    collection = "collection",
+    customer = "customer",
+    draft_order = "draft_order",
+    location = "location",
+    market = "market",
+    order = "order",
+    page = "page",
+    product = "product",
+    variant = "variant"
+}
+export declare enum MetafieldSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    type = "type",
+    updatedAt = "updatedAt"
+}
+export declare enum MetafieldType {
+    article_ref = "article_ref",
+    audio = "audio",
+    blog_ref = "blog_ref",
+    boolean = "boolean",
+    collection_ref = "collection_ref",
+    color = "color",
+    date = "date",
+    date_time = "date_time",
+    dimension = "dimension",
+    file = "file",
+    float = "float",
+    image = "image",
+    integer = "integer",
+    json = "json",
+    meta_object_ref = "meta_object_ref",
+    money = "money",
+    multiline_text = "multiline_text",
+    page_ref = "page_ref",
+    product_ref = "product_ref",
+    rating = "rating",
+    rich_text = "rich_text",
+    single_line_text = "single_line_text",
+    url = "url",
+    variant_ref = "variant_ref",
+    video = "video",
+    weight = "weight"
+}
+export type MultipleDeletes = {
+    __typename: 'MultipleDeletes';
+    message?: Maybe<Scalars['String']['output']>;
+    refs?: Maybe<Array<Maybe<Scalars['ID']['output']>>>;
+};
+export type Mutation = {
+    __typename: 'Mutation';
+    acceptStoreInvitation?: Maybe<Scalars['String']['output']>;
+    acceptStoreOwnership?: Maybe<Scalars['String']['output']>;
+    accountLogin?: Maybe<Scalars['String']['output']>;
+    addArticle?: Maybe<Article>;
+    addBlog?: Maybe<Blog>;
+    addCollection?: Maybe<Collection>;
+    addCollectionProduct?: Maybe<CollectionProduct>;
+    addCollectionProducts?: Maybe<Array<Maybe<CollectionProduct>>>;
+    addCollections?: Maybe<Array<Maybe<Collection>>>;
+    addDomain?: Maybe<Domain>;
+    addDomains?: Maybe<Array<Maybe<Domain>>>;
+    addInventories?: Maybe<Array<Maybe<Inventory>>>;
+    addInventory?: Maybe<Inventory>;
+    addLinklist?: Maybe<Linklist>;
+    addLocation?: Maybe<Location>;
+    addMarket?: Maybe<Market>;
+    addMarketVariant?: Maybe<MarketVariant>;
+    addMarketVariants?: Maybe<Array<Maybe<MarketVariant>>>;
+    addMarkets?: Maybe<Array<Maybe<Market>>>;
+    addMedia?: Maybe<Media>;
+    addMedias?: Maybe<Array<Maybe<Media>>>;
+    addMetafield?: Maybe<Metafield>;
+    addPreset?: Maybe<Preset>;
+    addPresets?: Maybe<Array<Maybe<Preset>>>;
+    addProduct?: Maybe<Product>;
+    addProducts?: Maybe<Array<Maybe<Product>>>;
+    addRedirect?: Maybe<Redirect>;
+    addRedirects?: Maybe<Array<Maybe<Redirect>>>;
+    addStaff?: Maybe<Staff>;
+    addStaffs?: Maybe<Array<Maybe<Staff>>>;
+    addVariant?: Maybe<Variant>;
+    addVariants?: Maybe<Array<Maybe<Variant>>>;
+    createAccount?: Maybe<Scalars['String']['output']>;
+    createAccountPasskey?: Maybe<Scalars['String']['output']>;
+    createStore?: Maybe<Scalars['String']['output']>;
+    deleteArticle?: Maybe<Scalars['String']['output']>;
+    deleteBlog?: Maybe<Scalars['String']['output']>;
+    deleteCollection?: Maybe<SingleDelete>;
+    deleteCollectionProduct?: Maybe<SingleDelete>;
+    deleteCollectionProducts?: Maybe<MultipleDeletes>;
+    deleteCollections?: Maybe<MultipleDeletes>;
+    deleteDomain?: Maybe<SingleDelete>;
+    deleteDomains?: Maybe<MultipleDeletes>;
+    deleteInventories?: Maybe<MultipleDeletes>;
+    deleteInventory?: Maybe<SingleDelete>;
+    deleteLinklist?: Maybe<Scalars['String']['output']>;
+    deleteLocation?: Maybe<Scalars['String']['output']>;
+    deleteMarket?: Maybe<SingleDelete>;
+    deleteMarketVariant?: Maybe<SingleDelete>;
+    deleteMarketVariants?: Maybe<MultipleDeletes>;
+    deleteMarkets?: Maybe<MultipleDeletes>;
+    deleteMedia?: Maybe<SingleDelete>;
+    deleteMedias?: Maybe<MultipleDeletes>;
+    deleteMetafield?: Maybe<Scalars['String']['output']>;
+    deletePreset?: Maybe<SingleDelete>;
+    deletePresets?: Maybe<MultipleDeletes>;
+    deleteProduct?: Maybe<SingleDelete>;
+    deleteProducts?: Maybe<MultipleDeletes>;
+    deleteRedirect?: Maybe<SingleDelete>;
+    deleteRedirects?: Maybe<MultipleDeletes>;
+    deleteStaff?: Maybe<SingleDelete>;
+    deleteStaffs?: Maybe<MultipleDeletes>;
+    deleteUserDevice?: Maybe<SingleDelete>;
+    deleteUserDevices?: Maybe<MultipleDeletes>;
+    deleteUserPasskey?: Maybe<SingleDelete>;
+    deleteUserPasskeys?: Maybe<MultipleDeletes>;
+    deleteUserSession?: Maybe<SingleDelete>;
+    deleteUserSessions?: Maybe<MultipleDeletes>;
+    deleteVariant?: Maybe<SingleDelete>;
+    deleteVariants?: Maybe<MultipleDeletes>;
+    disableAccountSecurity?: Maybe<Scalars['String']['output']>;
+    editArticle?: Maybe<Article>;
+    editBlog?: Maybe<Blog>;
+    editBrand?: Maybe<Brand>;
+    editCheckout?: Maybe<Checkout>;
+    editCollection?: Maybe<Collection>;
+    editCollectionProduct?: Maybe<CollectionProduct>;
+    editCollectionProducts?: Maybe<Array<Maybe<CollectionProduct>>>;
+    editCollections?: Maybe<Collection>;
+    editDomain?: Maybe<Domain>;
+    editDomains?: Maybe<Array<Maybe<Domain>>>;
+    editInventories?: Maybe<Array<Maybe<Inventory>>>;
+    editInventory?: Maybe<Inventory>;
+    editLinklist?: Maybe<Linklist>;
+    editLocation?: Maybe<Location>;
+    editMarket?: Maybe<Market>;
+    editMarketVariant?: Maybe<MarketVariant>;
+    editMarketVariants?: Maybe<Array<Maybe<MarketVariant>>>;
+    editMarkets?: Maybe<Array<Maybe<Market>>>;
+    editMetafield?: Maybe<Metafield>;
+    editPolicy?: Maybe<Policy>;
+    editPreset?: Maybe<Preset>;
+    editPresets?: Maybe<Preset>;
+    editProduct?: Maybe<Product>;
+    editProducts?: Maybe<Array<Maybe<Product>>>;
+    editRedirect?: Maybe<Redirect>;
+    editRedirects?: Maybe<Array<Maybe<Redirect>>>;
+    editShop?: Maybe<Shop>;
+    editStaff?: Maybe<Staff>;
+    editStaffs?: Maybe<Array<Maybe<Staff>>>;
+    editStore?: Maybe<Store>;
+    editVariant?: Maybe<Variant>;
+    editVariants?: Maybe<Array<Maybe<Variant>>>;
+    enableAccountSecurity?: Maybe<Scalars['String']['output']>;
+    installApp?: Maybe<App>;
+    pinApp?: Maybe<App>;
+    removeBrandMedia?: Maybe<Brand>;
+    resetAccountPassword?: Maybe<Scalars['String']['output']>;
+    sendAccountEmailVerification?: Maybe<Scalars['String']['output']>;
+    sendAccountPasswordResetEmail?: Maybe<Scalars['String']['output']>;
+    sendStaffInvitationEmail?: Maybe<Scalars['String']['output']>;
+    storeAppToken?: Maybe<Scalars['String']['output']>;
+    storeUserToken?: Maybe<Scalars['String']['output']>;
+    transferStoreOwnership?: Maybe<Scalars['String']['output']>;
+    uninstallApp?: Maybe<Scalars['String']['output']>;
+    unpinApp?: Maybe<App>;
+    updateAccountEmail?: Maybe<Scalars['String']['output']>;
+    updateAccountPassword?: Maybe<Scalars['String']['output']>;
+    updateAccountPhone?: Maybe<Scalars['String']['output']>;
+    updateUser?: Maybe<User>;
+    verifyAccountEmail?: Maybe<Scalars['String']['output']>;
+};
+export type MutationAcceptStoreInvitationArgs = {
+    token: Scalars['String']['input'];
+};
+export type MutationAcceptStoreOwnershipArgs = {
+    token: Scalars['String']['input'];
+};
+export type MutationAccountLoginArgs = {
+    email?: InputMaybe<Scalars['String']['input']>;
+    method: LoginMethod;
+    oauthCode?: InputMaybe<Scalars['String']['input']>;
+    passkeyData?: InputMaybe<Scalars['JSON']['input']>;
+    password?: InputMaybe<Scalars['String']['input']>;
+    security_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationAddArticleArgs = {
+    blog?: InputMaybe<Scalars['ID']['input']>;
+    comment_permission?: InputMaybe<ArticleCommentPermission>;
+    content?: InputMaybe<Scalars['String']['input']>;
+    excerpt?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<ArticleStatus>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title: Scalars['String']['input'];
+};
+export type MutationAddBlogArgs = {
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationAddCollectionArgs = {
+    input: AddCollection;
+};
+export type MutationAddCollectionProductArgs = {
+    input: AddCollectionProduct;
+};
+export type MutationAddCollectionProductsArgs = {
+    input: Array<AddCollectionProduct>;
+};
+export type MutationAddCollectionsArgs = {
+    input: Array<AddCollection>;
+};
+export type MutationAddDomainArgs = {
+    input: AddDomain;
+};
+export type MutationAddDomainsArgs = {
+    input: Array<AddDomain>;
+};
+export type MutationAddInventoriesArgs = {
+    input: Array<AddInventory>;
+};
+export type MutationAddInventoryArgs = {
+    input: AddInventory;
+};
+export type MutationAddLinklistArgs = {
+    handle?: InputMaybe<Scalars['String']['input']>;
+    links?: InputMaybe<Array<InputMaybe<LinklistLayer1Input>>>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationAddLocationArgs = {
+    address1?: InputMaybe<Scalars['String']['input']>;
+    address2?: InputMaybe<Scalars['String']['input']>;
+    city?: InputMaybe<Scalars['String']['input']>;
+    country: Scalars['ID']['input'];
+    email?: InputMaybe<EmailInput>;
+    fulfill_online_orders?: InputMaybe<Scalars['Boolean']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    phone?: InputMaybe<PhoneInput>;
+    postal_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationAddMarketArgs = {
+    input: AddMarket;
+};
+export type MutationAddMarketVariantArgs = {
+    input: AddMarketVariant;
+};
+export type MutationAddMarketVariantsArgs = {
+    input: Array<AddMarketVariant>;
+};
+export type MutationAddMarketsArgs = {
+    input: Array<AddMarket>;
+};
+export type MutationAddMediaArgs = {
+    input: Scalars['Upload']['input'];
+};
+export type MutationAddMediasArgs = {
+    input: Array<Scalars['Upload']['input']>;
+};
+export type MutationAddMetafieldArgs = {
+    entry: MetafieldEntryType;
+    is_public?: InputMaybe<Scalars['Boolean']['input']>;
+    key: Scalars['String']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    scope: MetafieldScope;
+    type: MetafieldType;
+};
+export type MutationAddPresetArgs = {
+    input: AddPreset;
+};
+export type MutationAddPresetsArgs = {
+    input: Array<AddPreset>;
+};
+export type MutationAddProductArgs = {
+    input: AddProduct;
+};
+export type MutationAddProductsArgs = {
+    input?: InputMaybe<Array<AddProduct>>;
+};
+export type MutationAddRedirectArgs = {
+    input: AddRedirect;
+};
+export type MutationAddRedirectsArgs = {
+    input: Array<AddRedirect>;
+};
+export type MutationAddStaffArgs = {
+    input: AddStaff;
+};
+export type MutationAddStaffsArgs = {
+    input: Array<AddStaff>;
+};
+export type MutationAddVariantArgs = {
+    input?: InputMaybe<AddVariant>;
+};
+export type MutationAddVariantsArgs = {
+    input: Array<AddVariant>;
+};
+export type MutationCreateAccountArgs = {
+    email: Scalars['String']['input'];
+    first_name?: InputMaybe<Scalars['String']['input']>;
+    last_name?: InputMaybe<Scalars['String']['input']>;
+    password: Scalars['String']['input'];
+};
+export type MutationCreateAccountPasskeyArgs = {
+    passkeyData: Scalars['JSON']['input'];
+};
+export type MutationCreateStoreArgs = {
+    store_country: Scalars['ID']['input'];
+    store_name?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationDeleteArticleArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteBlogArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteCollectionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteCollectionProductArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteCollectionProductsArgs = {
+    cursor: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteCollectionsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteDomainArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteDomainsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteInventoriesArgs = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type MutationDeleteInventoryArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteLinklistArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteLocationArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteMarketArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteMarketVariantArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteMarketVariantsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteMarketsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteMediaArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteMediasArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteMetafieldArgs = {
+    metafield: Scalars['ID']['input'];
+};
+export type MutationDeletePresetArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeletePresetsArgs = {
+    cursor: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteProductArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteProductsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteRedirectArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteRedirectsArgs = {
+    cursor: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteStaffArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteStaffsArgs = {
+    cursor: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteUserDeviceArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteUserDevicesArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteUserPasskeyArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteUserPasskeysArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteUserSessionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteUserSessionsArgs = {
+    cursors: Array<Scalars['ID']['input']>;
+};
+export type MutationDeleteVariantArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationDeleteVariantsArgs = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type MutationDisableAccountSecurityArgs = {
+    security_code: Scalars['String']['input'];
+};
+export type MutationEditArticleArgs = {
+    author?: InputMaybe<Scalars['ID']['input']>;
+    blog?: InputMaybe<Scalars['ID']['input']>;
+    comment_permission?: InputMaybe<ArticleCommentPermission>;
+    content?: InputMaybe<Scalars['String']['input']>;
+    cursor: Scalars['ID']['input'];
+    excerpt?: InputMaybe<Scalars['String']['input']>;
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    status?: InputMaybe<ArticleStatus>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditBlogArgs = {
+    cursor: Scalars['ID']['input'];
+    handle?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    meta_description?: InputMaybe<Scalars['String']['input']>;
+    meta_tags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    meta_title?: InputMaybe<Scalars['String']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    template?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditBrandArgs = {
+    cover_image?: InputMaybe<Scalars['ID']['input']>;
+    default_logo?: InputMaybe<Scalars['ID']['input']>;
+    facebook?: InputMaybe<Scalars['String']['input']>;
+    pinterest?: InputMaybe<Scalars['String']['input']>;
+    primary_color?: InputMaybe<Scalars['String']['input']>;
+    secondary_color?: InputMaybe<Scalars['String']['input']>;
+    short_description?: InputMaybe<Scalars['String']['input']>;
+    slogan?: InputMaybe<Scalars['String']['input']>;
+    snapchat?: InputMaybe<Scalars['String']['input']>;
+    square_logo?: InputMaybe<Scalars['ID']['input']>;
+    tiktok?: InputMaybe<Scalars['String']['input']>;
+    tumbler?: InputMaybe<Scalars['String']['input']>;
+    twitter?: InputMaybe<Scalars['String']['input']>;
+    vimeo?: InputMaybe<Scalars['String']['input']>;
+    whatsapp?: InputMaybe<Scalars['String']['input']>;
+    youtube?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditCheckoutArgs = {
+    address2_requirement?: InputMaybe<CheckoutExcludeRequiredOptional>;
+    auto_archive_order?: InputMaybe<Scalars['Boolean']['input']>;
+    auto_fulfill_high_risk?: InputMaybe<Scalars['Boolean']['input']>;
+    auto_fulfill_notify_customer?: InputMaybe<Scalars['Boolean']['input']>;
+    auto_fulfillment?: InputMaybe<CheckoutAutoFulfillment>;
+    auto_select_email_subscription?: InputMaybe<Scalars['Boolean']['input']>;
+    company_requirement?: InputMaybe<CheckoutExcludeRequiredOptional>;
+    contact_method?: InputMaybe<CheckoutContactMethod>;
+    custom_script?: InputMaybe<Scalars['String']['input']>;
+    enable_tipping?: InputMaybe<Scalars['Boolean']['input']>;
+    hide_tipping?: InputMaybe<Scalars['Boolean']['input']>;
+    is_login_required?: InputMaybe<Scalars['Boolean']['input']>;
+    name_requirement?: InputMaybe<CheckoutNameRequirement>;
+    offer_address_suggestion?: InputMaybe<Scalars['Boolean']['input']>;
+    self_serve_return?: InputMaybe<Scalars['Boolean']['input']>;
+    shipping_phone_requirement?: InputMaybe<CheckoutExcludeRequiredOptional>;
+    show_email_subscription?: InputMaybe<Scalars['Boolean']['input']>;
+    show_login_link?: InputMaybe<Scalars['Boolean']['input']>;
+    show_sms_subscription?: InputMaybe<Scalars['Boolean']['input']>;
+    tipping_preset_1?: InputMaybe<Scalars['Float']['input']>;
+    tipping_preset_2?: InputMaybe<Scalars['Float']['input']>;
+    tipping_preset_3?: InputMaybe<Scalars['Float']['input']>;
+    use_shipping_as_billing?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type MutationEditCollectionArgs = {
+    input: EditCollection;
+};
+export type MutationEditCollectionProductArgs = {
+    input: EditCollectionProduct;
+};
+export type MutationEditCollectionProductsArgs = {
+    input?: InputMaybe<Array<EditCollectionProduct>>;
+};
+export type MutationEditCollectionsArgs = {
+    input?: InputMaybe<Array<EditCollection>>;
+};
+export type MutationEditDomainArgs = {
+    input: EditDomain;
+};
+export type MutationEditDomainsArgs = {
+    input: Array<EditDomain>;
+};
+export type MutationEditInventoriesArgs = {
+    input?: InputMaybe<Array<InputMaybe<EditInventory>>>;
+};
+export type MutationEditInventoryArgs = {
+    input: EditInventory;
+};
+export type MutationEditLinklistArgs = {
+    cursor: Scalars['ID']['input'];
+    handle?: InputMaybe<Scalars['String']['input']>;
+    links?: InputMaybe<Array<InputMaybe<LinklistLayer1Input>>>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditLocationArgs = {
+    address1?: InputMaybe<Scalars['String']['input']>;
+    address2?: InputMaybe<Scalars['String']['input']>;
+    city?: InputMaybe<Scalars['String']['input']>;
+    country?: InputMaybe<Scalars['ID']['input']>;
+    cursor: Scalars['ID']['input'];
+    email?: InputMaybe<EmailInput>;
+    fulfill_online_orders?: InputMaybe<Scalars['Boolean']['input']>;
+    is_default?: InputMaybe<Scalars['Boolean']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    phone?: InputMaybe<PhoneInput>;
+    postal_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditMarketArgs = {
+    input: EditMarket;
+};
+export type MutationEditMarketVariantArgs = {
+    input: EditMarketVariant;
+};
+export type MutationEditMarketVariantsArgs = {
+    input: Array<EditMarketVariant>;
+};
+export type MutationEditMarketsArgs = {
+    input: Array<EditMarket>;
+};
+export type MutationEditMetafieldArgs = {
+    is_public?: InputMaybe<Scalars['Boolean']['input']>;
+    metafield: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditPolicyArgs = {
+    input?: InputMaybe<EditPolicy>;
+};
+export type MutationEditPresetArgs = {
+    input: EditPreset;
+};
+export type MutationEditPresetsArgs = {
+    input: Array<EditPreset>;
+};
+export type MutationEditProductArgs = {
+    input: EditProduct;
+};
+export type MutationEditProductsArgs = {
+    input?: InputMaybe<Array<EditProduct>>;
+};
+export type MutationEditRedirectArgs = {
+    input: EditRedirect;
+};
+export type MutationEditRedirectsArgs = {
+    input: Array<EditRedirect>;
+};
+export type MutationEditShopArgs = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    is_restricted?: InputMaybe<Scalars['Boolean']['input']>;
+    message?: InputMaybe<Scalars['String']['input']>;
+    password?: InputMaybe<Scalars['String']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationEditStaffArgs = {
+    input: EditStaff;
+};
+export type MutationEditStaffsArgs = {
+    input: Array<EditStaff>;
+};
+export type MutationEditStoreArgs = {
+    input: EditStore;
+};
+export type MutationEditVariantArgs = {
+    input: EditVariant;
+};
+export type MutationEditVariantsArgs = {
+    input?: InputMaybe<Array<EditVariant>>;
+};
+export type MutationEnableAccountSecurityArgs = {
+    security_code: Scalars['String']['input'];
+};
+export type MutationInstallAppArgs = {
+    _app: Scalars['ID']['input'];
+};
+export type MutationPinAppArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationRemoveBrandMediaArgs = {
+    cover_image?: InputMaybe<Scalars['Boolean']['input']>;
+    default_logo?: InputMaybe<Scalars['Boolean']['input']>;
+    square_logo?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type MutationResetAccountPasswordArgs = {
+    password: Scalars['String']['input'];
+    token: Scalars['String']['input'];
+};
+export type MutationSendAccountEmailVerificationArgs = {
+    intent: AccountEmailIntent;
+};
+export type MutationSendAccountPasswordResetEmailArgs = {
+    email: Scalars['String']['input'];
+};
+export type MutationSendStaffInvitationEmailArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationStoreAppTokenArgs = {
+    app_id: Scalars['String']['input'];
+    app_secret: Scalars['String']['input'];
+    store: Scalars['ID']['input'];
+};
+export type MutationStoreUserTokenArgs = {
+    store: Scalars['ID']['input'];
+};
+export type MutationTransferStoreOwnershipArgs = {
+    email: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    security_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUninstallAppArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationUnpinAppArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type MutationUpdateAccountEmailArgs = {
+    action_intent: AccountEmailUpdateActionIntent;
+    email_intent: AccountEmailIntent;
+    new_email?: InputMaybe<Scalars['String']['input']>;
+    security_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUpdateAccountPasswordArgs = {
+    new_password: Scalars['String']['input'];
+    security_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUpdateAccountPhoneArgs = {
+    country: Scalars['ID']['input'];
+    new_number: Scalars['String']['input'];
+    security_code?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationUpdateUserArgs = {
+    first_name?: InputMaybe<Scalars['String']['input']>;
+    language?: InputMaybe<Scalars['ID']['input']>;
+    last_name?: InputMaybe<Scalars['String']['input']>;
+    new_avatar?: InputMaybe<Scalars['Upload']['input']>;
+    remove_avatar?: InputMaybe<Scalars['Boolean']['input']>;
+    timezone?: InputMaybe<Scalars['ID']['input']>;
+};
+export type MutationVerifyAccountEmailArgs = {
+    token: Scalars['String']['input'];
+};
+export type PageInfo = {
+    __typename: 'PageInfo';
+    endCursor?: Maybe<Scalars['String']['output']>;
+    hasNextPage?: Maybe<Scalars['Boolean']['output']>;
+    hasPreviousPage?: Maybe<Scalars['Boolean']['output']>;
+    startCursor?: Maybe<Scalars['String']['output']>;
+};
+export type Passkey = {
+    __typename: 'Passkey';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    device_name?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    transports?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type Phone = {
+    __typename: 'Phone';
+    country?: Maybe<_Country>;
+    has_subscribed?: Maybe<Scalars['Boolean']['output']>;
+    has_unsubscribed?: Maybe<Scalars['Boolean']['output']>;
+    is_verified?: Maybe<Scalars['Boolean']['output']>;
+    number?: Maybe<Scalars['String']['output']>;
+};
+export type PhoneInput = {
+    country: Scalars['ID']['input'];
+    has_subscribed?: InputMaybe<Scalars['Boolean']['input']>;
+    number: Scalars['String']['input'];
+};
+export type Plan = {
+    __typename: 'Plan';
+    active_from?: Maybe<Scalars['String']['output']>;
+    active_till?: Maybe<Scalars['String']['output']>;
+    is_on_trial?: Maybe<Scalars['Boolean']['output']>;
+    is_plan_cancelled?: Maybe<Scalars['Boolean']['output']>;
+    locations?: Maybe<Scalars['Int']['output']>;
+    markets?: Maybe<Scalars['Int']['output']>;
+    package?: Maybe<_Package>;
+    package_discount_months?: Maybe<Scalars['Int']['output']>;
+    package_discounted_price?: Maybe<Scalars['Float']['output']>;
+    products?: Maybe<Scalars['Int']['output']>;
+    staffs?: Maybe<Scalars['Int']['output']>;
+    storage?: Maybe<Scalars['Int']['output']>;
+    store?: Maybe<Store>;
+    themes?: Maybe<Scalars['Int']['output']>;
+    unit_pricing?: Maybe<UnitPricing>;
+};
+export type Policy = {
+    __typename: 'Policy';
+    contact_information?: Maybe<Scalars['String']['output']>;
+    privacy_policy?: Maybe<Scalars['String']['output']>;
+    return_policy?: Maybe<Scalars['String']['output']>;
+    return_restocking_fee?: Maybe<Scalars['Float']['output']>;
+    return_shipping_charge?: Maybe<Scalars['Float']['output']>;
+    return_status?: Maybe<Scalars['Boolean']['output']>;
+    return_window?: Maybe<Scalars['Int']['output']>;
+    sale_collections?: Maybe<Array<Maybe<Collection>>>;
+    sale_products?: Maybe<Array<Maybe<Product>>>;
+    shipping_policy?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    terms_of_service?: Maybe<Scalars['String']['output']>;
+};
+export type Preset = {
+    __typename: 'Preset';
+    _id: Scalars['ID']['output'];
+    createdAt?: Maybe<Scalars['String']['output']>;
+    data?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<PresetType>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type PresetConnection = {
+    __typename: 'PresetConnection';
+    edges?: Maybe<Array<Maybe<PresetEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type PresetEdge = {
+    __typename: 'PresetEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Preset>;
+};
+export type PresetFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+    types?: InputMaybe<Array<PresetType>>;
+};
+export declare enum PresetSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt"
+}
+export declare enum PresetType {
+    analytics = "analytics",
+    collections = "collections",
+    customers = "customers",
+    inventories = "inventories",
+    orders = "orders",
+    paginations = "paginations",
+    products = "products",
+    purchases = "purchases",
+    transfers = "transfers"
+}
+export type PriceBreak = {
+    __typename: 'PriceBreak';
+    minimum_quantity?: Maybe<Scalars['Int']['output']>;
+    unit_price?: Maybe<Scalars['Float']['output']>;
+};
+export type PriceBreakInput = {
+    minimum_quantity: Scalars['Int']['input'];
+    unit_price: Scalars['Float']['input'];
+};
+export type Product = {
+    __typename: 'Product';
+    _id?: Maybe<Scalars['ID']['output']>;
+    category?: Maybe<_Category>;
+    description?: Maybe<Scalars['String']['output']>;
+    handle?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<Media>;
+    media?: Maybe<Array<Maybe<Media>>>;
+    meta_description?: Maybe<Scalars['String']['output']>;
+    meta_tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    meta_title?: Maybe<Scalars['String']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    option1?: Maybe<Scalars['String']['output']>;
+    option2?: Maybe<Scalars['String']['output']>;
+    option3?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<ProductStatus>;
+    store?: Maybe<Store>;
+    tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    template?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+    vendor?: Maybe<Scalars['String']['output']>;
+};
+export type ProductConnection = {
+    __typename: 'ProductConnection';
+    edges?: Maybe<Array<Maybe<ProductEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type ProductEdge = {
+    __typename: 'ProductEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Product>;
+};
+export type ProductFilterKeys = {
+    categories?: InputMaybe<Array<Scalars['ID']['input']>>;
+    collections?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    meta_tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    statuses?: InputMaybe<Array<ProductStatus>>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    templates?: InputMaybe<Array<Scalars['String']['input']>>;
+    types?: InputMaybe<Array<Scalars['String']['input']>>;
+    vendors?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum ProductSortKeys {
+    _id = "_id",
+    meta_tags = "meta_tags",
+    meta_title = "meta_title",
+    option1 = "option1",
+    option2 = "option2",
+    option3 = "option3",
+    status = "status",
+    template = "template",
+    title = "title",
+    type = "type",
+    vendor = "vendor"
+}
+export declare enum ProductStatus {
+    active = "active",
+    draft = "draft"
+}
+export type Publisher = {
+    __typename: 'Publisher';
+    _id?: Maybe<Scalars['ID']['output']>;
+    address?: Maybe<Scalars['String']['output']>;
+    apps?: Maybe<_AppConnection>;
+    banner?: Maybe<Scalars['String']['output']>;
+    brand_name?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<_Country>;
+    description?: Maybe<Scalars['String']['output']>;
+    email?: Maybe<Scalars['String']['output']>;
+    legal_name?: Maybe<Scalars['String']['output']>;
+    logo?: Maybe<Scalars['String']['output']>;
+    phone?: Maybe<Scalars['String']['output']>;
+    themes?: Maybe<_ThemeConnection>;
+    website?: Maybe<Scalars['String']['output']>;
+};
+export type PublisherAppsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_AppFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_AppSortKeys>;
+};
+export type PublisherThemesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeSortKeys>;
+};
+export type QuantityRule = {
+    __typename: 'QuantityRule';
+    increment?: Maybe<Scalars['Int']['output']>;
+    max?: Maybe<Scalars['Int']['output']>;
+    min?: Maybe<Scalars['Int']['output']>;
+};
+export type QuantityRuleInput = {
+    increment?: InputMaybe<Scalars['Int']['input']>;
+    max?: InputMaybe<Scalars['Int']['input']>;
+    min?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Query = {
+    __typename: 'Query';
+    CollectionProduct?: Maybe<CollectionProduct>;
+    CollectionProducts?: Maybe<CollectionProductConnection>;
+    _app?: Maybe<_App>;
+    _appCategories?: Maybe<Array<Maybe<_AppCategory>>>;
+    _apps?: Maybe<_AppConnection>;
+    _categories?: Maybe<_CategoryConnection>;
+    _category?: Maybe<_Category>;
+    _continent?: Maybe<_Continent>;
+    _continents?: Maybe<_ContinentConnection>;
+    _countries?: Maybe<_CountryConnection>;
+    _country?: Maybe<_Country>;
+    _currencies?: Maybe<_CurrencyConnection>;
+    _currency?: Maybe<_Currency>;
+    _hscode?: Maybe<_Hscode>;
+    _hscodes?: Maybe<_HscodeConnection>;
+    _language?: Maybe<_Language>;
+    _languages?: Maybe<_LanguageConnection>;
+    _package?: Maybe<_Package>;
+    _packages?: Maybe<_PackageConnection>;
+    _paymentGateway?: Maybe<_PaymentGateway>;
+    _paymentGateways?: Maybe<_PaymentGatewayConnection>;
+    _paymentProvider?: Maybe<_PaymentProvider>;
+    _paymentProviders?: Maybe<_PaymentProviderConnection>;
+    _phone?: Maybe<_Phone>;
+    _phones?: Maybe<_PhoneConnection>;
+    _region?: Maybe<_Region>;
+    _regions?: Maybe<_RegionConnection>;
+    _soppiyaPayment?: Maybe<_SoppiyaPayment>;
+    _soppiyaPayments?: Maybe<_SoppiyaPaymentConnection>;
+    _theme?: Maybe<_Theme>;
+    _themeCategories?: Maybe<Array<Maybe<_ThemeCategory>>>;
+    _themeVersion?: Maybe<_ThemeVersion>;
+    _themeVersions?: Maybe<_ThemeVersionConnection>;
+    _themes?: Maybe<_ThemeConnection>;
+    _timezone?: Maybe<_Timezone>;
+    _timezones?: Maybe<_TimezoneConnection>;
+    accountPasskeyLoginOptions?: Maybe<Scalars['JSON']['output']>;
+    accountPasskeyOptions?: Maybe<Scalars['JSON']['output']>;
+    accountSecurity?: Maybe<AccountSecurity>;
+    accountSecurityQRCode?: Maybe<Scalars['String']['output']>;
+    app?: Maybe<App>;
+    apps?: Maybe<AppConnection>;
+    article?: Maybe<Article>;
+    articles?: Maybe<ArticleConnection>;
+    blog?: Maybe<Blog>;
+    blogs?: Maybe<BlogConnection>;
+    brand?: Maybe<Brand>;
+    checkout?: Maybe<Checkout>;
+    collection?: Maybe<Collection>;
+    collections?: Maybe<CollectionConnection>;
+    domain?: Maybe<Domain>;
+    domains?: Maybe<DomainConnection>;
+    inventories?: Maybe<InventoryConnection>;
+    inventory?: Maybe<Inventory>;
+    linklist?: Maybe<Linklist>;
+    linklists?: Maybe<LinklistConnection>;
+    location?: Maybe<Location>;
+    locations?: Maybe<LocationConnection>;
+    market?: Maybe<Market>;
+    marketCountries?: Maybe<Array<Maybe<MarketCountry>>>;
+    marketVariant?: Maybe<MarketVariant>;
+    marketVariants?: Maybe<MarketVariantConnection>;
+    markets?: Maybe<MarketConnection>;
+    media?: Maybe<Media>;
+    mediaUsage?: Maybe<Scalars['String']['output']>;
+    medias?: Maybe<MediaConnection>;
+    metafield?: Maybe<Metafield>;
+    metafields?: Maybe<MetafieldConnection>;
+    plan?: Maybe<Plan>;
+    policy?: Maybe<Policy>;
+    preset?: Maybe<Preset>;
+    presets?: Maybe<PresetConnection>;
+    product?: Maybe<Product>;
+    products?: Maybe<ProductConnection>;
+    publisher?: Maybe<Publisher>;
+    redirect?: Maybe<Redirect>;
+    redirects?: Maybe<RedirectConnection>;
+    shop?: Maybe<Shop>;
+    staff?: Maybe<Staff>;
+    staffs?: Maybe<StaffConnection>;
+    store?: Maybe<Store>;
+    storeEvents?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    storeInvitationDetails?: Maybe<StoreInvitationDetails>;
+    storeOwnershipDetails?: Maybe<StoreOwnershipDetails>;
+    stores?: Maybe<StoreConnection>;
+    traceMe?: Maybe<Traceme>;
+    user?: Maybe<User>;
+    userDevice?: Maybe<Device>;
+    userDevices?: Maybe<UserDeviceConnection>;
+    userPasskey?: Maybe<Passkey>;
+    userPasskeys?: Maybe<UserPasskeyConnection>;
+    userSession?: Maybe<Session>;
+    userSessions?: Maybe<UserSessionConnection>;
+    variant?: Maybe<Variant>;
+    variants?: Maybe<VariantConnection>;
+    whoami?: Maybe<Whoami>;
+};
+export type QueryCollectionProductArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryCollectionProductsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<CollectionProductFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<CollectionProductSortkey>;
+};
+export type Query_AppArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_AppsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_AppFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_AppSortKeys>;
+};
+export type Query_CategoriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CategoryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CategorySortKeys>;
+};
+export type Query_CategoryArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_ContinentArgs = {
+    cursor?: InputMaybe<Scalars['ID']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type Query_ContinentsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ContinentFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ContinentSortKeys>;
+};
+export type Query_CountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type Query_CountryArgs = {
+    cursor?: InputMaybe<Scalars['ID']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type Query_CurrenciesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CurrencyFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CurrencySortKeys>;
+};
+export type Query_CurrencyArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_HscodeArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_HscodesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_HscodeFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_HscodeSortKeys>;
+};
+export type Query_LanguageArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_LanguagesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_LanguageFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_LanguageSortKeys>;
+};
+export type Query_PackageArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_PackagesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_PackageFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_PackageSortKeys>;
+};
+export type Query_PaymentGatewayArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_PaymentGatewaysArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_PaymentGatewayFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_PaymentGatewaySortKeys>;
+};
+export type Query_PaymentProviderArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_PaymentProvidersArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_PaymentProviderFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_PaymentProviderSortKeys>;
+};
+export type Query_PhoneArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_PhonesArgs = {
+    filterKeys?: InputMaybe<_PhoneFilterKeys>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    sortKey?: InputMaybe<_PhoneSortKeys>;
+};
+export type Query_RegionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_RegionsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_RegionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_RegionSortKeys>;
+};
+export type Query_SoppiyaPaymentArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_SoppiyaPaymentsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_SoppiyaPaymentFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_SoppiyaPaymentSortKeys>;
+};
+export type Query_ThemeArgs = {
+    cursor?: InputMaybe<Scalars['ID']['input']>;
+};
+export type Query_ThemeVersionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type Query_ThemeVersionsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeVersionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeVersionSortKeys>;
+};
+export type Query_ThemesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeSortKeys>;
+};
+export type Query_TimezoneArgs = {
+    cursor?: InputMaybe<Scalars['ID']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type Query_TimezonesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_TimezoneFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_TimezoneSortKeys>;
+};
+export type QueryAccountSecurityArgs = {
+    email: Scalars['String']['input'];
+};
+export type QueryAppArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryAppsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<AppFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<AppSortKeys>;
+};
+export type QueryArticleArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryArticlesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<ArticleFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<ArticleSortKeys>;
+};
+export type QueryBlogArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryBlogsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<BlogFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<BlogSortKeys>;
+};
+export type QueryCollectionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryCollectionsArgs = {
+    filterKeys?: InputMaybe<CollectionFilterKeys>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    sortKey?: InputMaybe<CollectionSortKey>;
+};
+export type QueryDomainArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryDomainsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<DomainFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<DomainSortkeys>;
+};
+export type QueryInventoriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<InventoryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<InventorySortKeys>;
+};
+export type QueryInventoryArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryLinklistArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryLinklistsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<LinklistFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<LinklistSortKeys>;
+};
+export type QueryLocationArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryLocationsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<LocationFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<LocationSortKeys>;
+};
+export type QueryMarketArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryMarketVariantArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryMarketVariantsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<MarketVariantFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MarketVariantSortKeys>;
+};
+export type QueryMarketsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<MarketFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MarketSortKeys>;
+};
+export type QueryMediaArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryMediasArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<MediaFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MediaSortKeys>;
+};
+export type QueryMetafieldArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryMetafieldsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<MetafieldFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MetafieldSortKeys>;
+};
+export type QueryPresetArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryPresetsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<PresetFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<PresetSortKeys>;
+};
+export type QueryProductArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryProductsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<ProductFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<ProductSortKeys>;
+};
+export type QueryPublisherArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryRedirectArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryRedirectsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<RedirectFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<RedirectSortKeys>;
+};
+export type QueryStaffArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryStaffsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<StaffFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<StaffSortKeys>;
+};
+export type QueryStoreInvitationDetailsArgs = {
+    token: Scalars['String']['input'];
+};
+export type QueryStoreOwnershipDetailsArgs = {
+    token: Scalars['String']['input'];
+};
+export type QueryStoresArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<StoreFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<StoreSortkeys>;
+};
+export type QueryUserDeviceArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryUserDevicesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<UserDeviceFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<UserDeviceSortKeys>;
+};
+export type QueryUserPasskeyArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryUserPasskeysArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<UserPasskeyFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<UserPasskeySortKeys>;
+};
+export type QueryUserSessionArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryUserSessionsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<UserSessionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<UserSessionSortKeys>;
+};
+export type QueryVariantArgs = {
+    cursor: Scalars['ID']['input'];
+};
+export type QueryVariantsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<VariantFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<VariantSortKeys>;
+};
+export type Redirect = {
+    __typename: 'Redirect';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    from?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    to?: Maybe<Scalars['String']['output']>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type RedirectConnection = {
+    __typename: 'RedirectConnection';
+    edges?: Maybe<Array<Maybe<RedirectEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type RedirectEdge = {
+    __typename: 'RedirectEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Redirect>;
+};
+export type RedirectFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export declare enum RedirectSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    from = "from",
+    to = "to",
+    updatedAt = "updatedAt"
+}
+export type Session = {
+    __typename: 'Session';
+    _id?: Maybe<Scalars['ID']['output']>;
+    city?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<Scalars['String']['output']>;
+    device?: Maybe<Device>;
+    ip?: Maybe<Scalars['String']['output']>;
+    isThisSession?: Maybe<Scalars['Boolean']['output']>;
+    latitude?: Maybe<Scalars['Float']['output']>;
+    longitude?: Maybe<Scalars['Float']['output']>;
+    subdivision?: Maybe<Scalars['String']['output']>;
+    time?: Maybe<Scalars['String']['output']>;
+};
+export type Shop = {
+    __typename: 'Shop';
+    description?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<Media>;
+    is_restricted?: Maybe<Scalars['Boolean']['output']>;
+    message?: Maybe<Scalars['String']['output']>;
+    password?: Maybe<Scalars['String']['output']>;
+    store?: Maybe<Store>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type SingleDelete = {
+    __typename: 'SingleDelete';
+    message?: Maybe<Scalars['String']['output']>;
+    ref?: Maybe<Scalars['ID']['output']>;
+};
+export type Staff = {
+    __typename: 'Staff';
+    _id?: Maybe<Scalars['ID']['output']>;
+    app_permission?: Maybe<StaffAppPermission>;
+    is_pending?: Maybe<Scalars['Boolean']['output']>;
+    is_this_user?: Maybe<Scalars['Boolean']['output']>;
+    last_session?: Maybe<Session>;
+    limited_apps?: Maybe<Array<Maybe<App>>>;
+    permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    store?: Maybe<Store>;
+    user?: Maybe<User>;
+};
+export declare enum StaffAppPermission {
+    all = "all",
+    denied = "denied",
+    limited = "limited"
+}
+export type StaffConnection = {
+    __typename: 'StaffConnection';
+    edges?: Maybe<Array<Maybe<StaffEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type StaffEdge = {
+    __typename: 'StaffEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Staff>;
+};
+export type StaffFilterKeys = {
+    app_permissions?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    is_pending?: InputMaybe<Scalars['Boolean']['input']>;
+    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum StaffSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    updatedAt = "updatedAt"
+}
+export type Store = {
+    __typename: 'Store';
+    _id?: Maybe<Scalars['ID']['output']>;
+    active_till?: Maybe<Scalars['String']['output']>;
+    address?: Maybe<Address>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    default_domain?: Maybe<Domain>;
+    events?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    length_unit?: Maybe<StoreLengthUnit>;
+    logo?: Maybe<Media>;
+    name?: Maybe<Scalars['String']['output']>;
+    order_prefix?: Maybe<Scalars['String']['output']>;
+    order_suffix?: Maybe<Scalars['String']['output']>;
+    owner?: Maybe<User>;
+    permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    plan?: Maybe<Plan>;
+    timezone?: Maybe<_Timezone>;
+    weight_unit?: Maybe<StoreWeightUnit>;
+};
+export type StoreConnection = {
+    __typename: 'StoreConnection';
+    edges?: Maybe<Array<Maybe<StoreEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type StoreEdge = {
+    __typename: 'StoreEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Store>;
+};
+export type StoreFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export type StoreInvitationDetails = {
+    __typename: 'StoreInvitationDetails';
+    expires_at?: Maybe<Scalars['String']['output']>;
+    invitation_by?: Maybe<User>;
+    invitation_for?: Maybe<User>;
+    is_pending?: Maybe<Scalars['Boolean']['output']>;
+    permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    store?: Maybe<Store>;
+};
+export declare enum StoreLengthUnit {
+    ft = "ft",
+    m = "m"
+}
+export type StoreOwnershipDetails = {
+    __typename: 'StoreOwnershipDetails';
+    expires_at?: Maybe<Scalars['String']['output']>;
+    owner?: Maybe<User>;
+    store?: Maybe<Store>;
+    user?: Maybe<User>;
+};
+export declare enum StoreSortkeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    name = "name",
+    updatedAt = "updatedAt"
+}
+export declare enum StoreWeightUnit {
+    kg = "kg",
+    lb = "lb"
+}
+export type Traceme = {
+    __typename: 'Traceme';
+    browser?: Maybe<Scalars['String']['output']>;
+    city?: Maybe<Scalars['String']['output']>;
+    continent?: Maybe<_Continent>;
+    country?: Maybe<_Country>;
+    device?: Maybe<Scalars['String']['output']>;
+    engine?: Maybe<Scalars['String']['output']>;
+    ip?: Maybe<Scalars['String']['output']>;
+    latitude?: Maybe<Scalars['Float']['output']>;
+    longitude?: Maybe<Scalars['Float']['output']>;
+    os?: Maybe<Scalars['String']['output']>;
+    postal_code?: Maybe<Scalars['String']['output']>;
+    subdivision?: Maybe<Scalars['String']['output']>;
+    timezone?: Maybe<_Timezone>;
+    ua?: Maybe<Scalars['String']['output']>;
+};
+export type TwoFactorAuthentication = {
+    __typename: 'TwoFactorAuthentication';
+    change_ownership?: Maybe<Scalars['Boolean']['output']>;
+    change_phone?: Maybe<Scalars['Boolean']['output']>;
+    login?: Maybe<Scalars['Boolean']['output']>;
+    update_password?: Maybe<Scalars['Boolean']['output']>;
+    update_primary_email?: Maybe<Scalars['Boolean']['output']>;
+    update_secondary_email?: Maybe<Scalars['Boolean']['output']>;
+};
+export type UnitPricing = {
+    __typename: 'UnitPricing';
+    location?: Maybe<Scalars['Float']['output']>;
+    market?: Maybe<Scalars['Float']['output']>;
+    product?: Maybe<Scalars['Float']['output']>;
+    staff?: Maybe<Scalars['Float']['output']>;
+    storage?: Maybe<Scalars['Float']['output']>;
+    theme?: Maybe<Scalars['Float']['output']>;
+};
+export type User = {
+    __typename: 'User';
+    _id?: Maybe<Scalars['ID']['output']>;
+    authenticator?: Maybe<Authenticator>;
+    avatar?: Maybe<Scalars['String']['output']>;
+    devices?: Maybe<UserDeviceConnection>;
+    email?: Maybe<Email>;
+    first_name?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<_Language>;
+    last_name?: Maybe<Scalars['String']['output']>;
+    phone?: Maybe<Phone>;
+    secondary_email?: Maybe<Email>;
+    timezone?: Maybe<_Timezone>;
+};
+export type UserDevicesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<UserDeviceFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<UserDeviceSortKeys>;
+};
+export type UserDeviceConnection = {
+    __typename: 'UserDeviceConnection';
+    edges?: Maybe<Array<Maybe<UserDeviceEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type UserDeviceEdge = {
+    __typename: 'UserDeviceEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Device>;
+};
+export type UserDeviceFilterKeys = {
+    browser_names?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    os_names?: InputMaybe<Array<Scalars['String']['input']>>;
+    uas?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum UserDeviceSortKeys {
+    _id = "_id",
+    browser_name = "browser_name",
+    os_name = "os_name"
+}
+export type UserPasskeyConnection = {
+    __typename: 'UserPasskeyConnection';
+    edges?: Maybe<Array<Maybe<UserPasskeyEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type UserPasskeyEdge = {
+    __typename: 'UserPasskeyEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Passkey>;
+};
+export type UserPasskeyFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    device_names?: InputMaybe<Array<Scalars['String']['input']>>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    transports?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum UserPasskeySortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    device_name = "device_name",
+    id = "id",
+    transports = "transports",
+    updatedAt = "updatedAt"
+}
+export type UserSessionConnection = {
+    __typename: 'UserSessionConnection';
+    edges?: Maybe<Array<Maybe<UserSessionEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type UserSessionEdge = {
+    __typename: 'UserSessionEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Session>;
+};
+export type UserSessionFilterKeys = {
+    countries?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    devices?: InputMaybe<Array<Scalars['ID']['input']>>;
+    ips?: InputMaybe<Array<Scalars['String']['input']>>;
+    subdivisions?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum UserSessionSortKeys {
+    _id = "_id",
+    city = "city",
+    country = "country",
+    device = "device",
+    ip = "ip",
+    latitude = "latitude",
+    longitude = "longitude",
+    subdivision = "subdivision",
+    time = "time"
+}
+export type Variant = {
+    __typename: 'Variant';
+    _id?: Maybe<Scalars['ID']['output']>;
+    barcode?: Maybe<Scalars['String']['output']>;
+    cost_per_item?: Maybe<Scalars['Float']['output']>;
+    country_of_origin?: Maybe<_Country>;
+    height?: Maybe<Scalars['Float']['output']>;
+    hs_code?: Maybe<_Hscode>;
+    image?: Maybe<Media>;
+    is_shipping_applicable?: Maybe<Scalars['Boolean']['output']>;
+    length?: Maybe<Scalars['Float']['output']>;
+    metafields?: Maybe<Array<Maybe<MetafieldData>>>;
+    option1?: Maybe<Scalars['String']['output']>;
+    option2?: Maybe<Scalars['String']['output']>;
+    option3?: Maybe<Scalars['String']['output']>;
+    product?: Maybe<Product>;
+    status?: Maybe<VariantStatus>;
+    store?: Maybe<Store>;
+    weight?: Maybe<Scalars['Float']['output']>;
+    width?: Maybe<Scalars['Float']['output']>;
+};
+export type VariantConnection = {
+    __typename: 'VariantConnection';
+    edges?: Maybe<Array<Maybe<VariantEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type VariantEdge = {
+    __typename: 'VariantEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<Variant>;
+};
+export type VariantFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    products?: InputMaybe<Array<Scalars['ID']['input']>>;
+    shipping_profiles?: InputMaybe<Array<Scalars['ID']['input']>>;
+    statuses?: InputMaybe<Array<VariantStatus>>;
+};
+export type VariantInput = {
+    MarketVariants?: InputMaybe<Array<InputMaybe<MarketVariantInput>>>;
+    barcode?: InputMaybe<Scalars['String']['input']>;
+    cost_per_item?: InputMaybe<Scalars['Float']['input']>;
+    country_of_origin?: InputMaybe<Scalars['ID']['input']>;
+    height?: InputMaybe<Scalars['Float']['input']>;
+    hs_code?: InputMaybe<Scalars['ID']['input']>;
+    image?: InputMaybe<Scalars['ID']['input']>;
+    inventories?: InputMaybe<Array<InputMaybe<InventoryInput>>>;
+    is_shipping_applicable?: InputMaybe<Scalars['Boolean']['input']>;
+    length?: InputMaybe<Scalars['Float']['input']>;
+    metafields?: InputMaybe<Array<InputMaybe<MetafieldInput>>>;
+    option1?: InputMaybe<Scalars['String']['input']>;
+    option2?: InputMaybe<Scalars['String']['input']>;
+    option3?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<VariantStatus>;
+    weight?: InputMaybe<Scalars['Float']['input']>;
+    width?: InputMaybe<Scalars['Float']['input']>;
+};
+export declare enum VariantSortKeys {
+    _id = "_id",
+    available = "available",
+    committed = "committed",
+    createdAt = "createdAt",
+    damaged = "damaged",
+    incoming = "incoming",
+    on_hand = "on_hand",
+    quality_control = "quality_control",
+    reserved = "reserved",
+    safety_stock = "safety_stock",
+    sku = "sku",
+    title = "title",
+    updatedAt = "updatedAt"
+}
+export declare enum VariantStatus {
+    active = "active",
+    archived = "archived",
+    draft = "draft"
+}
+export type Whoami = {
+    __typename: 'Whoami';
+    app?: Maybe<App>;
+    app_permission?: Maybe<StaffAppPermission>;
+    limited_apps?: Maybe<Array<Maybe<Scalars['ID']['output']>>>;
+    permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    store?: Maybe<Store>;
+    type?: Maybe<WhoamiType>;
+    user?: Maybe<User>;
+};
+export declare enum WhoamiType {
+    APP = "APP",
+    USER = "USER"
+}
+export type _App = {
+    __typename: '_App';
+    _id?: Maybe<Scalars['ID']['output']>;
+    categories?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    distribution?: Maybe<Scalars['String']['output']>;
+    events?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    handle?: Maybe<Scalars['String']['output']>;
+    icon?: Maybe<Scalars['String']['output']>;
+    installs?: Maybe<Scalars['Int']['output']>;
+    permissions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    publisher?: Maybe<Publisher>;
+    related?: Maybe<_AppConnection>;
+    thumbnail?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    updatedAt?: Maybe<Scalars['String']['output']>;
+};
+export type _AppRelatedArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_AppFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_AppSortKeys>;
+};
+export type _AppCategory = {
+    __typename: '_AppCategory';
+    apps?: Maybe<_AppConnection>;
+    count?: Maybe<Scalars['Int']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type _AppCategoryAppsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_AppFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_AppSortKeys>;
+};
+export type _AppConnection = {
+    __typename: '_AppConnection';
+    edges?: Maybe<Array<Maybe<_AppEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _AppEdge = {
+    __typename: '_AppEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_App>;
+};
+export type _AppFilterKeys = {
+    categories?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    handles?: InputMaybe<Array<Scalars['String']['input']>>;
+    publishers?: InputMaybe<Array<Scalars['ID']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _AppSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    title = "title",
+    updatedAt = "updatedAt"
+}
+export type _Category = {
+    __typename: '_Category';
+    _id?: Maybe<Scalars['ID']['output']>;
+    has_children?: Maybe<Scalars['Boolean']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    parent?: Maybe<_Category>;
+};
+export type _CategoryConnection = {
+    __typename: '_CategoryConnection';
+    edges?: Maybe<Array<Maybe<_CategoryEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _CategoryEdge = {
+    __typename: '_CategoryEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Category>;
+};
+export type _CategoryFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    parents?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export declare enum _CategorySortKeys {
+    _id = "_id",
+    has_children = "has_children",
+    name = "name",
+    parent = "parent"
+}
+export type _Continent = {
+    __typename: '_Continent';
+    _id?: Maybe<Scalars['ID']['output']>;
+    countries?: Maybe<_CountryConnection>;
+    name?: Maybe<Scalars['String']['output']>;
+};
+export type _ContinentCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _ContinentConnection = {
+    __typename: '_ContinentConnection';
+    edges?: Maybe<Array<Maybe<_ContinentEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _ContinentEdge = {
+    __typename: '_ContinentEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Continent>;
+};
+export type _ContinentFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _ContinentSortKeys {
+    _id = "_id",
+    name = "name"
+}
+export type _Country = {
+    __typename: '_Country';
+    _id?: Maybe<Scalars['ID']['output']>;
+    continent?: Maybe<_Continent>;
+    currencies?: Maybe<_CurrencyConnection>;
+    flag?: Maybe<Scalars['String']['output']>;
+    iso_3166_alpha2?: Maybe<Scalars['String']['output']>;
+    iso_3166_alpha3?: Maybe<Scalars['String']['output']>;
+    languages?: Maybe<_LanguageConnection>;
+    name?: Maybe<Scalars['String']['output']>;
+    native_name?: Maybe<Scalars['String']['output']>;
+    official_name?: Maybe<Scalars['String']['output']>;
+    phone?: Maybe<_Phone>;
+    regions?: Maybe<_RegionConnection>;
+    tax_name?: Maybe<Scalars['String']['output']>;
+    tax_rate?: Maybe<Scalars['Float']['output']>;
+};
+export type _CountryCurrenciesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CurrencyFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CurrencySortKeys>;
+};
+export type _CountryLanguagesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_LanguageFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_LanguageSortKeys>;
+};
+export type _CountryRegionsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_RegionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_RegionSortKeys>;
+};
+export type _CountryConnection = {
+    __typename: '_CountryConnection';
+    edges?: Maybe<Array<Maybe<_CountryEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _CountryEdge = {
+    __typename: '_CountryEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Country>;
+};
+export type _CountryFilterKeys = {
+    _continents?: InputMaybe<Array<Scalars['ID']['input']>>;
+    _currencies?: InputMaybe<Array<Scalars['ID']['input']>>;
+    _languages?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    iso_3166_alpha2s?: InputMaybe<Array<Scalars['String']['input']>>;
+    iso_3166_alpha3s?: InputMaybe<Array<Scalars['String']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    tax_names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _CountrySortKeys {
+    _id = "_id",
+    iso_3166_alpha2 = "iso_3166_alpha2",
+    iso_3166_alpha3 = "iso_3166_alpha3",
+    name = "name",
+    native_name = "native_name",
+    official_name = "official_name"
+}
+export type _Currency = {
+    __typename: '_Currency';
+    _id?: Maybe<Scalars['ID']['output']>;
+    conversion_rate?: Maybe<Scalars['Float']['output']>;
+    countries?: Maybe<_CountryConnection>;
+    iso_4217_code?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    native_name?: Maybe<Scalars['String']['output']>;
+    symbol?: Maybe<Scalars['String']['output']>;
+};
+export type _CurrencyCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _CurrencyConnection = {
+    __typename: '_CurrencyConnection';
+    edges?: Maybe<Array<Maybe<_CurrencyEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _CurrencyEdge = {
+    __typename: '_CurrencyEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Currency>;
+};
+export type _CurrencyFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    conversion_rates?: InputMaybe<Array<Scalars['Float']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    native_names?: InputMaybe<Array<Scalars['String']['input']>>;
+    symbols?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _CurrencySortKeys {
+    _id = "_id",
+    conversion_rate = "conversion_rate",
+    iso_4217_code = "iso_4217_code",
+    name = "name",
+    native_name = "native_name",
+    symbol = "symbol"
+}
+export type _Hscode = {
+    __typename: '_Hscode';
+    _id?: Maybe<Scalars['ID']['output']>;
+    code?: Maybe<Scalars['String']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+};
+export type _HscodeConnection = {
+    __typename: '_HscodeConnection';
+    edges?: Maybe<Array<Maybe<_HscodeEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _HscodeEdge = {
+    __typename: '_HscodeEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Hscode>;
+};
+export type _HscodeFilterKeys = {
+    codes?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+export declare enum _HscodeSortKeys {
+    _id = "_id",
+    code = "code",
+    description = "description"
+}
+export type _Language = {
+    __typename: '_Language';
+    _id?: Maybe<Scalars['ID']['output']>;
+    countries?: Maybe<_CountryConnection>;
+    iso_6391_code?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    native_name?: Maybe<Scalars['String']['output']>;
+};
+export type _LanguageCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _LanguageConnection = {
+    __typename: '_LanguageConnection';
+    edges?: Maybe<Array<Maybe<_LanguageEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _LanguageEdge = {
+    __typename: '_LanguageEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Language>;
+};
+export type _LanguageFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    iso_6391_codes?: InputMaybe<Array<Scalars['String']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    native_names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _LanguageSortKeys {
+    _id = "_id",
+    iso_6391_code = "iso_6391_code",
+    name = "name",
+    native_name = "native_name"
+}
+export type _Package = {
+    __typename: '_Package';
+    _id?: Maybe<Scalars['ID']['output']>;
+    discount_applicable_months?: Maybe<Scalars['Int']['output']>;
+    discounted_price?: Maybe<Scalars['Float']['output']>;
+    locations?: Maybe<Scalars['Int']['output']>;
+    markets?: Maybe<Scalars['Int']['output']>;
+    moto?: Maybe<Scalars['String']['output']>;
+    moto_details?: Maybe<Scalars['String']['output']>;
+    price?: Maybe<Scalars['Float']['output']>;
+    products?: Maybe<Scalars['Int']['output']>;
+    selling_plan?: Maybe<Array<Maybe<_PackageSellingPlan>>>;
+    staffs?: Maybe<Scalars['Int']['output']>;
+    storage?: Maybe<Scalars['Int']['output']>;
+    themes?: Maybe<Scalars['Int']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type _PackageConnection = {
+    __typename: '_PackageConnection';
+    edges?: Maybe<Array<Maybe<_PackageEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _PackageEdge = {
+    __typename: '_PackageEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Package>;
+};
+export type _PackageFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type _PackageSellingPlan = {
+    __typename: '_PackageSellingPlan';
+    amount?: Maybe<Scalars['Float']['output']>;
+    months?: Maybe<Scalars['Int']['output']>;
+};
+export declare enum _PackageSortKeys {
+    _id = "_id",
+    title = "title"
+}
+export type _PaymentGateway = {
+    __typename: '_PaymentGateway';
+    _id?: Maybe<Scalars['ID']['output']>;
+    icon?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+};
+export type _PaymentGatewayConnection = {
+    __typename: '_PaymentGatewayConnection';
+    edges?: Maybe<Array<Maybe<_PaymentGatewayEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _PaymentGatewayEdge = {
+    __typename: '_PaymentGatewayEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_PaymentGateway>;
+};
+export type _PaymentGatewayFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _PaymentGatewaySortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    name = "name"
+}
+export type _PaymentProvider = {
+    __typename: '_PaymentProvider';
+    _id?: Maybe<Scalars['ID']['output']>;
+    content?: Maybe<Scalars['String']['output']>;
+    countries?: Maybe<_CountryConnection>;
+    excerpt?: Maybe<Scalars['String']['output']>;
+    gateways?: Maybe<_PaymentGatewayConnection>;
+    icon?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    settings?: Maybe<Array<Maybe<_PaymentProviderSetting>>>;
+};
+export type _PaymentProviderCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _PaymentProviderGatewaysArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_PaymentGatewayFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_PaymentGatewaySortKeys>;
+};
+export type _PaymentProviderConnection = {
+    __typename: '_PaymentProviderConnection';
+    edges?: Maybe<Array<Maybe<_PaymentProviderEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _PaymentProviderEdge = {
+    __typename: '_PaymentProviderEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_PaymentProvider>;
+};
+export type _PaymentProviderFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    _gateways?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export type _PaymentProviderSetting = {
+    __typename: '_PaymentProviderSetting';
+    key?: Maybe<Scalars['String']['output']>;
+    label?: Maybe<Scalars['String']['output']>;
+};
+export declare enum _PaymentProviderSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    name = "name"
+}
+export type _Phone = {
+    __typename: '_Phone';
+    _id?: Maybe<Scalars['ID']['output']>;
+    countries?: Maybe<_CountryConnection>;
+    dialing_code?: Maybe<Scalars['String']['output']>;
+    format?: Maybe<Scalars['String']['output']>;
+};
+export type _PhoneCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _PhoneConnection = {
+    __typename: '_PhoneConnection';
+    edges?: Maybe<Array<Maybe<_PhoneEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _PhoneEdge = {
+    __typename: '_PhoneEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Phone>;
+};
+export type _PhoneFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    dialing_codes?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _PhoneSortKeys {
+    _id = "_id",
+    dialing_code = "dialing_code",
+    format = "format"
+}
+export type _Region = {
+    __typename: '_Region';
+    _id?: Maybe<Scalars['ID']['output']>;
+    country?: Maybe<_Country>;
+    name?: Maybe<Scalars['String']['output']>;
+    tax_name?: Maybe<Scalars['String']['output']>;
+    tax_rate?: Maybe<Scalars['Float']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+};
+export type _RegionConnection = {
+    __typename: '_RegionConnection';
+    edges?: Maybe<Array<Maybe<_RegionEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _RegionEdge = {
+    __typename: '_RegionEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Region>;
+};
+export type _RegionFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    tax_names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _RegionSortKeys {
+    _id = "_id",
+    country = "country",
+    name = "name",
+    tax_name = "tax_name",
+    tax_rate = "tax_rate",
+    type = "type"
+}
+export type _SoppiyaPayment = {
+    __typename: '_SoppiyaPayment';
+    _id?: Maybe<Scalars['ID']['output']>;
+    charge?: Maybe<_SoppiyaPaymentCharge>;
+    countries?: Maybe<_CountryConnection>;
+    provider?: Maybe<_PaymentProvider>;
+};
+export type _SoppiyaPaymentCountriesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_CountryFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_CountrySortKeys>;
+};
+export type _SoppiyaPaymentCharge = {
+    __typename: '_SoppiyaPaymentCharge';
+    amount?: Maybe<Scalars['Float']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+};
+export type _SoppiyaPaymentConnection = {
+    __typename: '_SoppiyaPaymentConnection';
+    edges?: Maybe<Array<Maybe<_SoppiyaPaymentEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _SoppiyaPaymentEdge = {
+    __typename: '_SoppiyaPaymentEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_SoppiyaPayment>;
+};
+export type _SoppiyaPaymentFilterKeys = {
+    _countries?: InputMaybe<Array<Scalars['ID']['input']>>;
+    _providers?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _SoppiyaPaymentSortKeys {
+    _id = "_id"
+}
+export type _Theme = {
+    __typename: '_Theme';
+    _id?: Maybe<Scalars['ID']['output']>;
+    categories?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    demo_store?: Maybe<Scalars['String']['output']>;
+    description?: Maybe<Scalars['String']['output']>;
+    desktop_preview?: Maybe<Scalars['String']['output']>;
+    documentation_url?: Maybe<Scalars['String']['output']>;
+    excerpt?: Maybe<Scalars['String']['output']>;
+    installs?: Maybe<Scalars['Int']['output']>;
+    mobile_preview?: Maybe<Scalars['String']['output']>;
+    price?: Maybe<Scalars['Float']['output']>;
+    publisher?: Maybe<Publisher>;
+    related?: Maybe<_ThemeConnection>;
+    support_url?: Maybe<Scalars['String']['output']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    thumbnail?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    versions?: Maybe<_ThemeVersionConnection>;
+};
+export type _ThemeRelatedArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeSortKeys>;
+};
+export type _ThemeVersionsArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeVersionFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeVersionSortKeys>;
+};
+export type _ThemeCategory = {
+    __typename: '_ThemeCategory';
+    count?: Maybe<Scalars['Int']['output']>;
+    themes?: Maybe<_ThemeConnection>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type _ThemeCategoryThemesArgs = {
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    filterKeys?: InputMaybe<_ThemeFilterKeys>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<_ThemeSortKeys>;
+};
+export type _ThemeConnection = {
+    __typename: '_ThemeConnection';
+    edges?: Maybe<Array<Maybe<_ThemeEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _ThemeEdge = {
+    __typename: '_ThemeEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Theme>;
+};
+export type _ThemeFilterKeys = {
+    categories?: InputMaybe<Array<Scalars['String']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    prices?: InputMaybe<Array<Scalars['Float']['input']>>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _ThemeSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    price = "price",
+    title = "title"
+}
+export type _ThemeVersion = {
+    __typename: '_ThemeVersion';
+    _id?: Maybe<Scalars['ID']['output']>;
+    createdAt?: Maybe<Scalars['String']['output']>;
+    fixes?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    note?: Maybe<Scalars['String']['output']>;
+    number?: Maybe<Scalars['String']['output']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    theme?: Maybe<_Theme>;
+    thumbnail?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+};
+export type _ThemeVersionConnection = {
+    __typename: '_ThemeVersionConnection';
+    edges?: Maybe<Array<Maybe<_ThemeVersionEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _ThemeVersionEdge = {
+    __typename: '_ThemeVersionEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_ThemeVersion>;
+};
+export type _ThemeVersionFilterKeys = {
+    _themes?: InputMaybe<Array<Scalars['ID']['input']>>;
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    tags?: InputMaybe<Array<Scalars['String']['input']>>;
+    titles?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+export declare enum _ThemeVersionSortKeys {
+    _id = "_id",
+    createdAt = "createdAt",
+    title = "title"
+}
+export type _Timezone = {
+    __typename: '_Timezone';
+    _id?: Maybe<Scalars['ID']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    offset?: Maybe<Scalars['Int']['output']>;
+};
+export type _TimezoneConnection = {
+    __typename: '_TimezoneConnection';
+    edges?: Maybe<Array<Maybe<_TimezoneEdge>>>;
+    pageInfo?: Maybe<PageInfo>;
+    totalCount?: Maybe<Scalars['Int']['output']>;
+};
+export type _TimezoneEdge = {
+    __typename: '_TimezoneEdge';
+    cursor?: Maybe<Scalars['ID']['output']>;
+    node?: Maybe<_Timezone>;
+};
+export type _TimezoneFilterKeys = {
+    cursors?: InputMaybe<Array<Scalars['ID']['input']>>;
+    names?: InputMaybe<Array<Scalars['String']['input']>>;
+    offsets?: InputMaybe<Array<Scalars['Int']['input']>>;
+};
+export declare enum _TimezoneSortKeys {
+    _id = "_id",
+    name = "name",
+    offset = "offset"
+}
+export type MediasQueryVariables = Exact<{
+    after?: InputMaybe<Scalars['ID']['input']>;
+    before?: InputMaybe<Scalars['ID']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    query?: InputMaybe<Scalars['String']['input']>;
+    reverse?: InputMaybe<Scalars['Boolean']['input']>;
+    sortKey?: InputMaybe<MediaSortKeys>;
+    filterKeys?: InputMaybe<MediaFilterKeys>;
+}>;
+export type MediasQuery = {
+    medias?: {
+        __typename: 'MediaConnection';
+        edges?: Array<{
+            __typename: 'MediaEdge';
+            node?: {
+                __typename: 'Media';
+                _id?: string | null;
+                file_name?: string | null;
+                url?: string | null;
+                size?: string | null;
+                type?: MediaType | null;
+                mimetype?: string | null;
+            } | null;
+        } | null> | null;
+        pageInfo?: {
+            __typename: 'PageInfo';
+            endCursor?: string | null;
+            hasNextPage?: boolean | null;
+            hasPreviousPage?: boolean | null;
+            startCursor?: string | null;
+        } | null;
+    } | null;
+};
+export type StoragePlanQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type StoragePlanQuery = {
+    plan?: {
+        __typename: 'Plan';
+        storage?: number | null;
+        package?: {
+            __typename: '_Package';
+            _id?: string | null;
+            storage?: number | null;
+        } | null;
+    } | null;
+};
+export type MediaUsageQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type MediaUsageQuery = {
+    mediaUsage?: string | null;
+};
+export type AddMediasMutationVariables = Exact<{
+    input: Array<Scalars['Upload']['input']> | Scalars['Upload']['input'];
+}>;
+export type AddMediasMutation = {
+    addMedias?: Array<{
+        __typename: 'Media';
+        _id?: string | null;
+        file_name?: string | null;
+        url?: string | null;
+        size?: string | null;
+    } | null> | null;
+};
+export type DeleteMediasMutationVariables = Exact<{
+    cursors: Array<Scalars['ID']['input']> | Scalars['ID']['input'];
+}>;
+export type DeleteMediasMutation = {
+    deleteMedias?: {
+        __typename: 'MultipleDeletes';
+        message?: string | null;
+    } | null;
+};
+export declare const MediasDocument: DocumentNode<MediasQuery, MediasQueryVariables>;
+export declare const StoragePlanDocument: DocumentNode<StoragePlanQuery, StoragePlanQueryVariables>;
+export declare const MediaUsageDocument: DocumentNode<MediaUsageQuery, MediaUsageQueryVariables>;
+export declare const AddMediasDocument: DocumentNode<AddMediasMutation, AddMediasMutationVariables>;
+export declare const DeleteMediasDocument: DocumentNode<DeleteMediasMutation, DeleteMediasMutationVariables>;