@zonos/elements 1.3.288 → 1.3.289

package/dist/types/types/generated/graphql.internal.types.ts

@@ -1,26 +1,15 @@
-import type { GraphQLClient } from 'graphql-request';
-import type { GraphQLClientRequestHeaders } from 'graphql-request/build/cjs/types';
-
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = Maybe<T>;
-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 };
+/** Internal type. DO NOT USE DIRECTLY. */
+/** Internal type. DO NOT USE DIRECTLY. */
 export type Incremental<T> =
   | T
   | {
       [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
     };
+import type { GraphQLClient, RequestOptions } from 'graphql-request';
+
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+type GraphQLClientRequestHeaders = RequestOptions['requestHeaders'];
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
   ID: { input: string; output: string };
@@ -554,6 +543,15 @@ export const aiModel = {
 
 export type AiModel = (typeof aiModel)[keyof typeof aiModel];
 
+export const airwallexAccountType = {
+  AirwallexAuCustomer: 'AIRWALLEX_AU_CUSTOMER',
+  AirwallexPaymentsCustomer: 'AIRWALLEX_PAYMENTS_CUSTOMER',
+  AirwallexUsCustomer: 'AIRWALLEX_US_CUSTOMER',
+} as const;
+
+export type AirwallexAccountType =
+  (typeof airwallexAccountType)[keyof typeof airwallexAccountType];
+
 export const airwallexPaymentLinkStatus = {
   Active: 'ACTIVE',
   Inactive: 'INACTIVE',
@@ -620,6 +618,12 @@ export const amsCertificateType = {
 
 export type AmsCertificateType =
   (typeof amsCertificateType)[keyof typeof amsCertificateType];
+export const amsDisclaimCode = {
+  A: 'A',
+} as const;
+
+export type AmsDisclaimCode =
+  (typeof amsDisclaimCode)[keyof typeof amsDisclaimCode];
 
 export const amsProgram = {
   Eg: 'EG',
@@ -1014,6 +1018,7 @@ export const brokerageCbpMessageCategory = {
   Carrier: 'CARRIER',
   Census: 'CENSUS',
   Classification: 'CLASSIFICATION',
+  Compliance: 'COMPLIANCE',
   Country: 'COUNTRY',
   Date: 'DATE',
   EntrySummary: 'ENTRY_SUMMARY',
@@ -1023,6 +1028,7 @@ export const brokerageCbpMessageCategory = {
   Pga: 'PGA',
   Port: 'PORT',
   Rollup: 'ROLLUP',
+  System: 'SYSTEM',
   Value: 'VALUE',
 } as const;
 
@@ -1090,8 +1096,86 @@ export const brokerageDocumentType = {
 export type BrokerageDocumentType =
   (typeof brokerageDocumentType)[keyof typeof brokerageDocumentType];
 
+export const brokerageDutyDisputeClaimType = {
+  CountryOfOrigin: 'COUNTRY_OF_ORIGIN',
+  DeclaredValue: 'DECLARED_VALUE',
+  Description: 'DESCRIPTION',
+  HsCode: 'HS_CODE',
+  Quantity: 'QUANTITY',
+  TariffLine: 'TARIFF_LINE',
+  Weight: 'WEIGHT',
+} as const;
+
+export type BrokerageDutyDisputeClaimType =
+  (typeof brokerageDutyDisputeClaimType)[keyof typeof brokerageDutyDisputeClaimType];
+
+export const brokerageDutyDisputeEventType = {
+  ClaimDecided: 'CLAIM_DECIDED',
+  Completed: 'COMPLETED',
+  Created: 'CREATED',
+  Expired: 'EXPIRED',
+  Note: 'NOTE',
+  ResolutionFailed: 'RESOLUTION_FAILED',
+  ResolutionRequested: 'RESOLUTION_REQUESTED',
+  Resolved: 'RESOLVED',
+  ReviewCompleted: 'REVIEW_COMPLETED',
+  ReviewRequested: 'REVIEW_REQUESTED',
+  Submitted: 'SUBMITTED',
+  Updated: 'UPDATED',
+  Withdrawn: 'WITHDRAWN',
+} as const;
+
+export type BrokerageDutyDisputeEventType =
+  (typeof brokerageDutyDisputeEventType)[keyof typeof brokerageDutyDisputeEventType];
+
+export const brokerageDutyDisputeIneligibilityReason = {
+  DisputeExists: 'DISPUTE_EXISTS',
+  NoDuties: 'NO_DUTIES',
+  NotFiled: 'NOT_FILED',
+  NotFound: 'NOT_FOUND',
+  Paid: 'PAID',
+  PastDeadline: 'PAST_DEADLINE',
+} as const;
+
+export type BrokerageDutyDisputeIneligibilityReason =
+  (typeof brokerageDutyDisputeIneligibilityReason)[keyof typeof brokerageDutyDisputeIneligibilityReason];
+
+export const brokerageDutyDisputeOutcome = {
+  Accepted: 'ACCEPTED',
+  Denied: 'DENIED',
+  Partial: 'PARTIAL',
+  Review: 'REVIEW',
+} as const;
+
+export type BrokerageDutyDisputeOutcome =
+  (typeof brokerageDutyDisputeOutcome)[keyof typeof brokerageDutyDisputeOutcome];
+export const brokerageDutyDisputeStatus = {
+  Complete: 'COMPLETE',
+  Draft: 'DRAFT',
+  Expired: 'EXPIRED',
+  ResolutionFailed: 'RESOLUTION_FAILED',
+  Resolved: 'RESOLVED',
+  Submitted: 'SUBMITTED',
+  UnderReview: 'UNDER_REVIEW',
+  Withdrawn: 'WITHDRAWN',
+} as const;
+
+export type BrokerageDutyDisputeStatus =
+  (typeof brokerageDutyDisputeStatus)[keyof typeof brokerageDutyDisputeStatus];
+
+export const brokerageDutyDisputeVerdict = {
+  Accepted: 'ACCEPTED',
+  Deferred: 'DEFERRED',
+  Denied: 'DENIED',
+  Review: 'REVIEW',
+} as const;
+
+export type BrokerageDutyDisputeVerdict =
+  (typeof brokerageDutyDisputeVerdict)[keyof typeof brokerageDutyDisputeVerdict];
+
 export const brokerageEntryClearanceStatus = {
   Accepted: 'ACCEPTED',
+  Cancelled: 'CANCELLED',
   CbpExam: 'CBP_EXAM',
   CbpHold: 'CBP_HOLD',
   Filed: 'FILED',
@@ -1175,6 +1259,40 @@ export const brokerageTransportationMode = {
 export type BrokerageTransportationMode =
   (typeof brokerageTransportationMode)[keyof typeof brokerageTransportationMode];
 
+export const brokerageWorkOrderResolution = {
+  CancelledAndRefiled: 'CANCELLED_AND_REFILED',
+  ConditionCleared: 'CONDITION_CLEARED',
+  CorrectedPrefile: 'CORRECTED_PREFILE',
+  NoActionRequired: 'NO_ACTION_REQUIRED',
+  ReferenceDataFixedResent: 'REFERENCE_DATA_FIXED_RESENT',
+  UnfileableAccepted: 'UNFILEABLE_ACCEPTED',
+} as const;
+
+export type BrokerageWorkOrderResolution =
+  (typeof brokerageWorkOrderResolution)[keyof typeof brokerageWorkOrderResolution];
+export const brokerageWorkOrderStatus = {
+  AutoResolved: 'AUTO_RESOLVED',
+  Cancelled: 'CANCELLED',
+  Open: 'OPEN',
+  Resolved: 'RESOLVED',
+} as const;
+
+export type BrokerageWorkOrderStatus =
+  (typeof brokerageWorkOrderStatus)[keyof typeof brokerageWorkOrderStatus];
+export const brokerageWorkOrderType = {
+  CbpExam: 'CBP_EXAM',
+  CbpHold: 'CBP_HOLD',
+  DeniedPartyReview: 'DENIED_PARTY_REVIEW',
+  EntryRejected: 'ENTRY_REJECTED',
+  PgaHold: 'PGA_HOLD',
+  SubmissionFailed: 'SUBMISSION_FAILED',
+  Unfileable: 'UNFILEABLE',
+  ValidationBlocked: 'VALIDATION_BLOCKED',
+} as const;
+
+export type BrokerageWorkOrderType =
+  (typeof brokerageWorkOrderType)[keyof typeof brokerageWorkOrderType];
+
 export const bulkJobStatus = {
   Error: 'ERROR',
   FileSaved: 'FILE_SAVED',
@@ -1656,6 +1774,27 @@ export const channelConnectionStatus = {
 export type ChannelConnectionStatus =
   (typeof channelConnectionStatus)[keyof typeof channelConnectionStatus];
 
+export const channelOrderImportJobStatus = {
+  Failed: 'FAILED',
+  Pending: 'PENDING',
+  Processing: 'PROCESSING',
+  Queued: 'QUEUED',
+  Succeeded: 'SUCCEEDED',
+  SucceededWithErrors: 'SUCCEEDED_WITH_ERRORS',
+} as const;
+
+export type ChannelOrderImportJobStatus =
+  (typeof channelOrderImportJobStatus)[keyof typeof channelOrderImportJobStatus];
+export const channelOrderImportRowOutcome = {
+  Created: 'CREATED',
+  Error: 'ERROR',
+  SkippedNoChange: 'SKIPPED_NO_CHANGE',
+  TrackingUpdated: 'TRACKING_UPDATED',
+} as const;
+
+export type ChannelOrderImportRowOutcome =
+  (typeof channelOrderImportRowOutcome)[keyof typeof channelOrderImportRowOutcome];
+
 export const channelType = {
   Amazon: 'AMAZON',
   Bigcommerce: 'BIGCOMMERCE',
@@ -1672,6 +1811,21 @@ export const channelType = {
 } as const;
 
 export type ChannelType = (typeof channelType)[keyof typeof channelType];
+export const chargeAttemptOutcome = {
+  HardDecline: 'HARD_DECLINE',
+  NetworkError: 'NETWORK_ERROR',
+  Pending: 'PENDING',
+  ProcessorError: 'PROCESSOR_ERROR',
+  Returned: 'RETURNED',
+  Settled: 'SETTLED',
+  SoftDecline: 'SOFT_DECLINE',
+  Submitted: 'SUBMITTED',
+  Succeeded: 'SUCCEEDED',
+} as const;
+
+export type ChargeAttemptOutcome =
+  (typeof chargeAttemptOutcome)[keyof typeof chargeAttemptOutcome];
+
 export const checkoutCartType = {
   Checkout: 'CHECKOUT',
   Collect: 'COLLECT',
@@ -2107,6 +2261,13 @@ export const connectTransferOriginType = {
 export type ConnectTransferOriginType =
   (typeof connectTransferOriginType)[keyof typeof connectTransferOriginType];
 
+export const consignmentReadinessProfile = {
+  ComplianceInferred: 'COMPLIANCE_INFERRED',
+  Standard: 'STANDARD',
+} as const;
+
+export type ConsignmentReadinessProfile =
+  (typeof consignmentReadinessProfile)[keyof typeof consignmentReadinessProfile];
 export const consignmentStatus = {
   Accepted: 'ACCEPTED',
   Archived: 'ARCHIVED',
@@ -3547,6 +3708,7 @@ export type EntityType = (typeof entityType)[keyof typeof entityType];
 export const entryStatus = {
   Accepted: 'ACCEPTED',
   Archived: 'ARCHIVED',
+  Cancelled: 'CANCELLED',
   Draft: 'DRAFT',
   Error: 'ERROR',
   Filed: 'FILED',
@@ -3709,6 +3871,7 @@ export type FdaAffirmationCategory =
 export const fdaAffirmationConditionField = {
   CountryOfOrigin: 'COUNTRY_OF_ORIGIN',
   EntityRole: 'ENTITY_ROLE',
+  ImpactResistantLens: 'IMPACT_RESISTANT_LENS',
   IntendedUseCode: 'INTENDED_USE_CODE',
   ModeOfTransport: 'MODE_OF_TRANSPORT',
   ProcessingCode: 'PROCESSING_CODE',
@@ -3716,6 +3879,7 @@ export const fdaAffirmationConditionField = {
   ProductCodePic: 'PRODUCT_CODE_PIC',
   ProductCodeSubclass: 'PRODUCT_CODE_SUBCLASS',
   Program: 'PROGRAM',
+  RadiationStandard: 'RADIATION_STANDARD',
 } as const;
 
 export type FdaAffirmationConditionField =
@@ -3749,6 +3913,15 @@ export const fdaProductCodeLevel = {
 export type FdaProductCodeLevel =
   (typeof fdaProductCodeLevel)[keyof typeof fdaProductCodeLevel];
 
+export const fdaRadiationStandardStatus = {
+  Applicable: 'APPLICABLE',
+  NonApplicable: 'NON_APPLICABLE',
+  Unknown: 'UNKNOWN',
+} as const;
+
+export type FdaRadiationStandardStatus =
+  (typeof fdaRadiationStandardStatus)[keyof typeof fdaRadiationStandardStatus];
+
 export const fedExCategoryCode = {
   Shipping: 'SHIPPING',
 } as const;
@@ -6585,6 +6758,13 @@ export const paymentType = {
 } as const;
 
 export type PaymentType = (typeof paymentType)[keyof typeof paymentType];
+export const paymentVaultProvider = {
+  BasisTheory: 'BASIS_THEORY',
+  Processor: 'PROCESSOR',
+} as const;
+
+export type PaymentVaultProvider =
+  (typeof paymentVaultProvider)[keyof typeof paymentVaultProvider];
 
 export const paypalMockResponse = {
   InstrumentDeclined: 'INSTRUMENT_DECLINED',
@@ -8612,6 +8792,7 @@ export const zonosInvoiceFinalizeAndChargeOutcome = {
 export type ZonosInvoiceFinalizeAndChargeOutcome =
   (typeof zonosInvoiceFinalizeAndChargeOutcome)[keyof typeof zonosInvoiceFinalizeAndChargeOutcome];
 export const zonosInvoiceInternalExclusionType = {
+  TerminalFinality: 'TERMINAL_FINALITY',
   ZeroAmount: 'ZERO_AMOUNT',
 } as const;
 
@@ -11028,12 +11209,14 @@ export type SdkFunctionWrapper = <T>(
   action: (requestHeaders?: Record<string, string>) => Promise<T>,
   operationName: string,
   operationType?: string,
+  variables?: { [x: string]: never },
 ) => Promise<T>;
 
 const defaultWrapper: SdkFunctionWrapper = (
   action,
   _operationName,
   _operationType,
+  _variables,
 ) => action();
 
 export function getSdk(
@@ -11044,1031 +11227,1315 @@ export function getSdk(
     activeDiscounts(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ActiveDiscountsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ActiveDiscountsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ActiveDiscountsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'activeDiscounts',
         'query',
+        variables,
       );
     },
     addTrackingNumber(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<AddTrackingNumberMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<AddTrackingNumberMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<AddTrackingNumberMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'addTrackingNumber',
         'mutation',
+        variables,
       );
     },
     appearanceSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<AppearanceSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<AppearanceSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<AppearanceSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'appearanceSettings',
         'query',
+        variables,
       );
     },
     bulkClassify(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<BulkClassifyMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<BulkClassifyMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<BulkClassifyMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'bulkClassify',
         'mutation',
+        variables,
       );
     },
     calculateLandedCost(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CalculateLandedCostMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CalculateLandedCostMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CalculateLandedCostMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'calculateLandedCost',
         'mutation',
+        variables,
       );
     },
     cart(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cart',
         'query',
+        variables,
       );
     },
     cartById(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartByIdQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartByIdQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartByIdQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cartById',
         'query',
+        variables,
       );
     },
     cartCalculateLandedCost(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartCalculateLandedCostMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartCalculateLandedCostMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartCalculateLandedCostMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cartCalculateLandedCost',
         'mutation',
+        variables,
       );
     },
     cartCheckoutWorkflow(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartCheckoutWorkflowQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartCheckoutWorkflowQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartCheckoutWorkflowQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cartCheckoutWorkflow',
         'query',
+        variables,
       );
     },
     cartCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cartCreate',
         'mutation',
+        variables,
       );
     },
     cartUpdate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CartUpdateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CartUpdateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CartUpdateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'cartUpdate',
         'mutation',
+        variables,
       );
     },
     channelConnectionCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ChannelConnectionCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ChannelConnectionCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ChannelConnectionCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'channelConnectionCreate',
         'mutation',
+        variables,
       );
     },
     channelConnectionDelete(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ChannelConnectionDeleteMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ChannelConnectionDeleteMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ChannelConnectionDeleteMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'channelConnectionDelete',
         'mutation',
+        variables,
       );
     },
     channelConnectionUpdate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ChannelConnectionUpdateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ChannelConnectionUpdateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ChannelConnectionUpdateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'channelConnectionUpdate',
         'mutation',
+        variables,
       );
     },
     checkItemRestrictions(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckItemRestrictionsMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckItemRestrictionsMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckItemRestrictionsMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkItemRestrictions',
         'mutation',
+        variables,
       );
     },
     checkoutCustomerProfileAuthenticate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutCustomerProfileAuthenticateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutCustomerProfileAuthenticateMutation>(
-            '',
+          client.request<CheckoutCustomerProfileAuthenticateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'checkoutCustomerProfileAuthenticate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionBaseCurrencyUpdate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionBaseCurrencyUpdateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionBaseCurrencyUpdateMutation>(
-            '',
+          client.request<CheckoutSessionBaseCurrencyUpdateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'checkoutSessionBaseCurrencyUpdate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckoutSessionCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkoutSessionCreate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionOrderCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionOrderCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionOrderCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckoutSessionOrderCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkoutSessionOrderCreate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionPaymentIntentCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionPaymentIntentCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionPaymentIntentCreateMutation>(
-            '',
+          client.request<CheckoutSessionPaymentIntentCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'checkoutSessionPaymentIntentCreate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionStoreCreditOrderCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionStoreCreditOrderCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionStoreCreditOrderCreateMutation>(
-            '',
+          client.request<CheckoutSessionStoreCreditOrderCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'checkoutSessionStoreCreditOrderCreate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionUpdate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionUpdateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionUpdateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckoutSessionUpdateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkoutSessionUpdate',
         'mutation',
+        variables,
       );
     },
     checkoutSessionUpdateAttributes(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionUpdateAttributesMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionUpdateAttributesMutation>(
-            '',
+          client.request<CheckoutSessionUpdateAttributesMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'checkoutSessionUpdateAttributes',
         'mutation',
+        variables,
       );
     },
     checkoutSessionUpdateMetadata(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSessionUpdateMetadataMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSessionUpdateMetadataMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckoutSessionUpdateMetadataMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkoutSessionUpdateMetadata',
         'mutation',
+        variables,
       );
     },
     checkoutSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CheckoutSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CheckoutSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CheckoutSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'checkoutSettings',
         'query',
+        variables,
       );
     },
     createCollectQuote(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CreateCollectQuoteMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CreateCollectQuoteMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CreateCollectQuoteMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'createCollectQuote',
         'mutation',
+        variables,
       );
     },
     createWebhook(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CreateWebhookMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CreateWebhookMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CreateWebhookMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'createWebhook',
         'mutation',
+        variables,
       );
     },
     currencyConversionCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<CurrencyConversionCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<CurrencyConversionCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<CurrencyConversionCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'currencyConversionCreate',
         'mutation',
+        variables,
       );
     },
     deleteWebhook(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<DeleteWebhookMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<DeleteWebhookMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<DeleteWebhookMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'deleteWebhook',
         'mutation',
+        variables,
       );
     },
     exchangeRateCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ExchangeRateCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ExchangeRateCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ExchangeRateCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'exchangeRateCreate',
         'mutation',
+        variables,
       );
     },
     fulfillmentCenter(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<FulfillmentCenterQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<FulfillmentCenterQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<FulfillmentCenterQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'fulfillmentCenter',
         'query',
+        variables,
       );
     },
     getAirwallexPaymentIntent(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetAirwallexPaymentIntentQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetAirwallexPaymentIntentQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetAirwallexPaymentIntentQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getAirwallexPaymentIntent',
         'query',
+        variables,
       );
     },
     getCartForCollectReceipt(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCartForCollectReceiptQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCartForCollectReceiptQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCartForCollectReceiptQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCartForCollectReceipt',
         'query',
+        variables,
       );
     },
     getCartInfo(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCartInfoQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCartInfoQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCartInfoQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCartInfo',
         'query',
+        variables,
       );
     },
     getCartOrganizationInfo(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCartOrganizationInfoQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCartOrganizationInfoQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCartOrganizationInfoQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCartOrganizationInfo',
         'query',
+        variables,
       );
     },
     getChannelConnections(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetChannelConnectionsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetChannelConnectionsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetChannelConnectionsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getChannelConnections',
         'query',
+        variables,
       );
     },
     getCheckoutPlaceOrderButtonSelector(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCheckoutPlaceOrderButtonSelectorQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCheckoutPlaceOrderButtonSelectorQuery>(
-            '',
+          client.request<GetCheckoutPlaceOrderButtonSelectorQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'getCheckoutPlaceOrderButtonSelector',
         'query',
+        variables,
       );
     },
     getCheckoutSession(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCheckoutSessionQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCheckoutSessionQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCheckoutSessionQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCheckoutSession',
         'query',
+        variables,
       );
     },
     getCheckoutSessionAttributes(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCheckoutSessionAttributesQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCheckoutSessionAttributesQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCheckoutSessionAttributesQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCheckoutSessionAttributes',
         'query',
+        variables,
       );
     },
     getCheckoutSessionReferences(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCheckoutSessionReferencesQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCheckoutSessionReferencesQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCheckoutSessionReferencesQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCheckoutSessionReferences',
         'query',
+        variables,
       );
     },
     getCollectCheckoutSession(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetCollectCheckoutSessionQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetCollectCheckoutSessionQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetCollectCheckoutSessionQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getCollectCheckoutSession',
         'query',
+        variables,
       );
     },
     getOrder(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetOrderQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetOrderQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetOrderQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getOrder',
         'query',
+        variables,
       );
     },
     getOrders(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetOrdersQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetOrdersQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetOrdersQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getOrders',
         'query',
+        variables,
       );
     },
     getPartyInfoByLandedCostId(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetPartyInfoByLandedCostIdQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetPartyInfoByLandedCostIdQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetPartyInfoByLandedCostIdQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getPartyInfoByLandedCostId',
         'query',
+        variables,
       );
     },
     getReceiptCheckoutSession(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetReceiptCheckoutSessionQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetReceiptCheckoutSessionQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetReceiptCheckoutSessionQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getReceiptCheckoutSession',
         'query',
+        variables,
       );
     },
     getReceiptOrder(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetReceiptOrderQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetReceiptOrderQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetReceiptOrderQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getReceiptOrder',
         'query',
+        variables,
       );
     },
     getTaxIdByCountry(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetTaxIdByCountryQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetTaxIdByCountryQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetTaxIdByCountryQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getTaxIdByCountry',
         'query',
+        variables,
       );
     },
     getWebhooks(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<GetWebhooksQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<GetWebhooksQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<GetWebhooksQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'getWebhooks',
         'query',
+        variables,
       );
     },
     helloSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<HelloSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<HelloSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<HelloSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'helloSettings',
         'query',
+        variables,
       );
     },
     inclusivePriceConfigurationId(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<InclusivePriceConfigurationIdQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<InclusivePriceConfigurationIdQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<InclusivePriceConfigurationIdQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'inclusivePriceConfigurationId',
         'query',
+        variables,
       );
     },
     inclusivePriceConfigurations(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<InclusivePriceConfigurationsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<InclusivePriceConfigurationsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<InclusivePriceConfigurationsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'inclusivePriceConfigurations',
         'query',
+        variables,
       );
     },
     inclusivePriceConfigurationsSync(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<InclusivePriceConfigurationsSyncMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<InclusivePriceConfigurationsSyncMutation>(
-            '',
+          client.request<InclusivePriceConfigurationsSyncMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'inclusivePriceConfigurationsSync',
         'mutation',
+        variables,
       );
     },
     landedCostSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<LandedCostSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<LandedCostSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<LandedCostSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'landedCostSettings',
         'query',
+        variables,
       );
     },
     onlineStoreSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<OnlineStoreSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<OnlineStoreSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<OnlineStoreSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'onlineStoreSettings',
         'query',
+        variables,
       );
     },
     orderUpdateAccountOrderNumber(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<OrderUpdateAccountOrderNumberMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<OrderUpdateAccountOrderNumberMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<OrderUpdateAccountOrderNumberMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'orderUpdateAccountOrderNumber',
         'mutation',
+        variables,
       );
     },
     organization(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<OrganizationQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<OrganizationQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<OrganizationQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'organization',
         'query',
+        variables,
       );
     },
     organizationByStoreId(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<OrganizationByStoreIdQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<OrganizationByStoreIdQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<OrganizationByStoreIdQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'organizationByStoreId',
         'query',
+        variables,
       );
     },
     organizations(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<OrganizationsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<OrganizationsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<OrganizationsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'organizations',
         'query',
+        variables,
       );
     },
     partyCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<PartyCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<PartyCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<PartyCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'partyCreate',
         'mutation',
+        variables,
       );
     },
     partyInfo(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<PartyInfoQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<PartyInfoQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<PartyInfoQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'partyInfo',
         'query',
+        variables,
       );
     },
     paypalOrder(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<PaypalOrderQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<PaypalOrderQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<PaypalOrderQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'paypalOrder',
         'query',
+        variables,
       );
     },
     paypalOrderCapture(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<PaypalOrderCaptureMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<PaypalOrderCaptureMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<PaypalOrderCaptureMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'paypalOrderCapture',
         'mutation',
+        variables,
       );
     },
     paypalOrderCreate(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<PaypalOrderCreateMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<PaypalOrderCreateMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<PaypalOrderCreateMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'paypalOrderCreate',
         'mutation',
+        variables,
       );
     },
     removeTrackingNumber(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<RemoveTrackingNumberMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<RemoveTrackingNumberMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<RemoveTrackingNumberMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'removeTrackingNumber',
         'mutation',
+        variables,
       );
     },
     renewCartExpirationToken(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<RenewCartExpirationTokenMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<RenewCartExpirationTokenMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<RenewCartExpirationTokenMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'renewCartExpirationToken',
         'mutation',
+        variables,
       );
     },
     selectCheckoutVarianceTest(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<SelectCheckoutVarianceTestMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<SelectCheckoutVarianceTestMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<SelectCheckoutVarianceTestMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'selectCheckoutVarianceTest',
         'mutation',
+        variables,
       );
     },
     shippingZones(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ShippingZonesQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ShippingZonesQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ShippingZonesQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'shippingZones',
         'query',
+        variables,
       );
     },
     storeCreditAddCredit(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<StoreCreditAddCreditMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<StoreCreditAddCreditMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<StoreCreditAddCreditMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'storeCreditAddCredit',
         'mutation',
+        variables,
       );
     },
     storeCreditApplyToCheckoutSession(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<StoreCreditApplyToCheckoutSessionMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<StoreCreditApplyToCheckoutSessionMutation>(
-            '',
+          client.request<StoreCreditApplyToCheckoutSessionMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
             variables,
-            { ...requestHeaders, ...wrappedRequestHeaders },
-          ),
+          }),
         'storeCreditApplyToCheckoutSession',
         'mutation',
+        variables,
       );
     },
     storeCreditRemoveCredit(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<StoreCreditRemoveCreditMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<StoreCreditRemoveCreditMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<StoreCreditRemoveCreditMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'storeCreditRemoveCredit',
         'mutation',
+        variables,
       );
     },
     storeCreditsByCustomer(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<StoreCreditsByCustomerQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<StoreCreditsByCustomerQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<StoreCreditsByCustomerQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'storeCreditsByCustomer',
         'query',
+        variables,
       );
     },
     updateWebhook(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<UpdateWebhookMutation> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<UpdateWebhookMutation>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<UpdateWebhookMutation>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'updateWebhook',
         'mutation',
+        variables,
       );
     },
     zonosSettings(
       variables?: { [x: string]: never },
       requestHeaders?: GraphQLClientRequestHeaders,
+      signal?: RequestInit['signal'],
     ): Promise<ZonosSettingsQuery> {
       return withWrapper(
         wrappedRequestHeaders =>
-          client.request<ZonosSettingsQuery>('', variables, {
-            ...requestHeaders,
-            ...wrappedRequestHeaders,
+          client.request<ZonosSettingsQuery>({
+            document: '',
+            requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+            signal,
+            variables,
           }),
         'zonosSettings',
         'query',
+        variables,
       );
     },
   };