@wix/ecom 1.0.763 → 1.0.764

package/type-bundles/service-plugins-context.bundle.d.ts

@@ -258,27 +258,26 @@ declare class AlreadyVoidedWixError extends Error {
     static readonly __type = "wix_spi_error";
 }
 
-type ServicePluginMethodInput = {
+type ServicePluginMethodInput$d = {
     request: any;
     metadata: any;
 };
-type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
-type ServicePluginMethodMetadata = {
+type ServicePluginContract$d = Record<string, (payload: ServicePluginMethodInput$d) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$d = {
     name: string;
     primaryHttpMappingPath: string;
     transformations: {
-        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$d;
         toREST: (...args: unknown[]) => unknown;
     };
 };
-type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+type ServicePluginDefinition$d<Contract extends ServicePluginContract$d> = {
     __type: 'service-plugin-definition';
     componentType: string;
-    methods: ServicePluginMethodMetadata[];
+    methods: ServicePluginMethodMetadata$d[];
     __contract: Contract;
 };
-declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
-type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+declare function ServicePluginDefinition$d<Contract extends ServicePluginContract$d>(componentType: string, methods: ServicePluginMethodMetadata$d[]): ServicePluginDefinition$d<Contract>;
 
 declare global {
 	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
@@ -287,6 +286,11 @@ declare global {
 	}
 }
 
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface GetBalanceEnvelope {
     request: GetBalanceRequest;
     metadata: Context$6;
@@ -299,7 +303,7 @@ interface _voidEnvelope {
     request: VoidRequest;
     metadata: Context$6;
 }
-declare const provideHandlers$d: ServicePluginDefinition<{
+declare const provideHandlers$d: ServicePluginDefinition$d<{
     /**
      *
      * This method retrieves gift card data from your app.
@@ -317,7 +321,36 @@ declare const provideHandlers$d: ServicePluginDefinition<{
     _void(payload: _voidEnvelope): VoidResponse | Promise<VoidResponse>;
 }>;
 
-declare function createServicePluginModule$6<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$c = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$c = Record<string, (payload: ServicePluginMethodInput$c) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$c = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$c;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$c<Contract extends ServicePluginContract$c> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$c[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$c<Contract extends ServicePluginContract$c>(componentType: string, methods: ServicePluginMethodMetadata$c[]): ServicePluginDefinition$c<Contract>;
+type BuildServicePluginDefinition$6<T extends ServicePluginDefinition$c<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$6<T extends ServicePluginDefinition$c<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$6<T> & T;
 
 type _publicProvideHandlersType$6 = typeof provideHandlers$d;
 declare const provideHandlers$c: ReturnType<typeof createServicePluginModule$6<_publicProvideHandlersType>>;
@@ -891,11 +924,44 @@ declare class GenericShippingRatesWixError extends Error {
     static readonly __type = "wix_spi_error";
 }
 
+type ServicePluginMethodInput$b = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$b = Record<string, (payload: ServicePluginMethodInput$b) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$b = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$b;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$b<Contract extends ServicePluginContract$b> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$b[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$b<Contract extends ServicePluginContract$b>(componentType: string, methods: ServicePluginMethodMetadata$b[]): ServicePluginDefinition$b<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface GetShippingRatesEnvelope {
     request: GetShippingRatesRequest;
     metadata: Context$5;
 }
-declare const provideHandlers$b: ServicePluginDefinition<{
+declare const provideHandlers$b: ServicePluginDefinition$b<{
     /**
      *
      * This method retrieves applicable shipping rates for a delivery from your app.
@@ -904,7 +970,36 @@ declare const provideHandlers$b: ServicePluginDefinition<{
     getShippingRates(payload: GetShippingRatesEnvelope): GetShippingRatesResponse | Promise<GetShippingRatesResponse>;
 }>;
 
-declare function createServicePluginModule$5<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$a = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$a = Record<string, (payload: ServicePluginMethodInput$a) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$a = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$a;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$a<Contract extends ServicePluginContract$a> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$a[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$a<Contract extends ServicePluginContract$a>(componentType: string, methods: ServicePluginMethodMetadata$a[]): ServicePluginDefinition$a<Contract>;
+type BuildServicePluginDefinition$5<T extends ServicePluginDefinition$a<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$5<T extends ServicePluginDefinition$a<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$5<T> & T;
 
 type _publicProvideHandlersType$5 = typeof provideHandlers$b;
 declare const provideHandlers$a: ReturnType<typeof createServicePluginModule$5<_publicProvideHandlersType>>;
@@ -1321,11 +1416,44 @@ interface IdentificationDataIdOneOf$4 {
     appId?: string;
 }
 
+type ServicePluginMethodInput$9 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$9 = Record<string, (payload: ServicePluginMethodInput$9) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$9 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$9;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$9<Contract extends ServicePluginContract$9> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$9[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$9<Contract extends ServicePluginContract$9>(componentType: string, methods: ServicePluginMethodMetadata$9[]): ServicePluginDefinition$9<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface CalculateAdditionalFeesEnvelope {
     request: CalculateAdditionalFeesRequest;
     metadata: Context$4;
 }
-declare const provideHandlers$9: ServicePluginDefinition<{
+declare const provideHandlers$9: ServicePluginDefinition$9<{
     /**
      *
      * This method retrieves additional fees calculated by your app.
@@ -1337,7 +1465,36 @@ declare const provideHandlers$9: ServicePluginDefinition<{
     calculateAdditionalFees(payload: CalculateAdditionalFeesEnvelope): CalculateAdditionalFeesResponse | Promise<CalculateAdditionalFeesResponse>;
 }>;
 
-declare function createServicePluginModule$4<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$8 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$8 = Record<string, (payload: ServicePluginMethodInput$8) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$8 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$8;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$8<Contract extends ServicePluginContract$8> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$8[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$8<Contract extends ServicePluginContract$8>(componentType: string, methods: ServicePluginMethodMetadata$8[]): ServicePluginDefinition$8<Contract>;
+type BuildServicePluginDefinition$4<T extends ServicePluginDefinition$8<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$4<T extends ServicePluginDefinition$8<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$4<T> & T;
 
 type _publicProvideHandlersType$4 = typeof provideHandlers$9;
 declare const provideHandlers$8: ReturnType<typeof createServicePluginModule$4<_publicProvideHandlersType>>;
@@ -1488,6 +1645,39 @@ interface IdentificationDataIdOneOf$3 {
     appId?: string;
 }
 
+type ServicePluginMethodInput$7 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$7 = Record<string, (payload: ServicePluginMethodInput$7) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$7 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$7;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$7<Contract extends ServicePluginContract$7> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$7[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$7<Contract extends ServicePluginContract$7>(componentType: string, methods: ServicePluginMethodMetadata$7[]): ServicePluginDefinition$7<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface ListTriggersEnvelope {
     request: ListTriggersRequest;
     metadata: Context$3;
@@ -1496,7 +1686,7 @@ interface GetEligibleTriggersEnvelope {
     request: GetEligibleTriggersRequest;
     metadata: Context$3;
 }
-declare const provideHandlers$7: ServicePluginDefinition<{
+declare const provideHandlers$7: ServicePluginDefinition$7<{
     /**
      *
      * Lists all custom triggers provided by your service plugin integration.
@@ -1512,7 +1702,36 @@ declare const provideHandlers$7: ServicePluginDefinition<{
     getEligibleTriggers(payload: GetEligibleTriggersEnvelope): GetEligibleTriggersResponse | Promise<GetEligibleTriggersResponse>;
 }>;
 
-declare function createServicePluginModule$3<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$6 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$6 = Record<string, (payload: ServicePluginMethodInput$6) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$6 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$6;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$6<Contract extends ServicePluginContract$6> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$6[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$6<Contract extends ServicePluginContract$6>(componentType: string, methods: ServicePluginMethodMetadata$6[]): ServicePluginDefinition$6<Contract>;
+type BuildServicePluginDefinition$3<T extends ServicePluginDefinition$6<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$3<T extends ServicePluginDefinition$6<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$3<T> & T;
 
 type _publicProvideHandlersType$3 = typeof provideHandlers$7;
 declare const provideHandlers$6: ReturnType<typeof createServicePluginModule$3<_publicProvideHandlersType>>;
@@ -1811,11 +2030,44 @@ declare class CouponDoesNotExistWixError extends Error {
     static readonly __type = "wix_spi_error";
 }
 
+type ServicePluginMethodInput$5 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$5 = Record<string, (payload: ServicePluginMethodInput$5) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$5 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$5;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$5<Contract extends ServicePluginContract$5> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$5[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$5<Contract extends ServicePluginContract$5>(componentType: string, methods: ServicePluginMethodMetadata$5[]): ServicePluginDefinition$5<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface GetEligibleDiscountsEnvelope {
     request: GetEligibleDiscountsRequest;
     metadata: Context$2;
 }
-declare const provideHandlers$5: ServicePluginDefinition<{
+declare const provideHandlers$5: ServicePluginDefinition$5<{
     /**
      *
      * Wix calls this method when certain actions are performed on the cart or checkout.
@@ -1823,7 +2075,36 @@ declare const provideHandlers$5: ServicePluginDefinition<{
     getEligibleDiscounts(payload: GetEligibleDiscountsEnvelope): GetEligibleDiscountsResponse | Promise<GetEligibleDiscountsResponse>;
 }>;
 
-declare function createServicePluginModule$2<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$4 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$4 = Record<string, (payload: ServicePluginMethodInput$4) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$4 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$4;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$4<Contract extends ServicePluginContract$4> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$4[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$4<Contract extends ServicePluginContract$4>(componentType: string, methods: ServicePluginMethodMetadata$4[]): ServicePluginDefinition$4<Contract>;
+type BuildServicePluginDefinition$2<T extends ServicePluginDefinition$4<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$2<T extends ServicePluginDefinition$4<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$2<T> & T;
 
 type _publicProvideHandlersType$2 = typeof provideHandlers$5;
 declare const provideHandlers$4: ReturnType<typeof createServicePluginModule$2<_publicProvideHandlersType>>;
@@ -4551,6 +4832,39 @@ interface IdentificationDataIdOneOf$1 {
     appId?: string;
 }
 
+type ServicePluginMethodInput$3 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$3 = Record<string, (payload: ServicePluginMethodInput$3) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$3 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$3;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$3<Contract extends ServicePluginContract$3> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$3[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$3<Contract extends ServicePluginContract$3>(componentType: string, methods: ServicePluginMethodMetadata$3[]): ServicePluginDefinition$3<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface GetPaymentSettingsEnvelope {
     request: GetPaymentSettingsRequest;
     metadata: Context$1;
@@ -4559,7 +4873,7 @@ interface GetPaymentSettingsForCheckoutEnvelope {
     request: GetPaymentSettingsForCheckoutRequest;
     metadata: Context$1;
 }
-declare const provideHandlers$3: ServicePluginDefinition<{
+declare const provideHandlers$3: ServicePluginDefinition$3<{
     /**
      *
      * This method retrieves payment settings from your app.
@@ -4572,7 +4886,36 @@ declare const provideHandlers$3: ServicePluginDefinition<{
     getPaymentSettingsForCheckout(payload: GetPaymentSettingsForCheckoutEnvelope): GetPaymentSettingsForCheckoutResponse | Promise<GetPaymentSettingsForCheckoutResponse>;
 }>;
 
-declare function createServicePluginModule$1<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
+type ServicePluginMethodInput$2 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$2 = Record<string, (payload: ServicePluginMethodInput$2) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$2 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$2;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$2<Contract extends ServicePluginContract$2> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$2[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$2<Contract extends ServicePluginContract$2>(componentType: string, methods: ServicePluginMethodMetadata$2[]): ServicePluginDefinition$2<Contract>;
+type BuildServicePluginDefinition$1<T extends ServicePluginDefinition$2<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function createServicePluginModule$1<T extends ServicePluginDefinition$2<any>>(servicePluginDefinition: T): BuildServicePluginDefinition$1<T> & T;
 
 type _publicProvideHandlersType$1 = typeof provideHandlers$3;
 declare const provideHandlers$2: ReturnType<typeof createServicePluginModule$1<_publicProvideHandlersType>>;
@@ -5406,11 +5749,44 @@ interface IdentificationDataIdOneOf {
     appId?: string;
 }
 
+type ServicePluginMethodInput$1 = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract$1 = Record<string, (payload: ServicePluginMethodInput$1) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata$1 = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput$1;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition$1<Contract extends ServicePluginContract$1> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata$1[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition$1<Contract extends ServicePluginContract$1>(componentType: string, methods: ServicePluginMethodMetadata$1[]): ServicePluginDefinition$1<Contract>;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare global {
+    interface ContextualClient {
+    }
+}
+
 interface GetValidationViolationsEnvelope {
     request: GetValidationViolationsRequest;
     metadata: Context;
 }
-declare const provideHandlers$1: ServicePluginDefinition<{
+declare const provideHandlers$1: ServicePluginDefinition$1<{
     /**
      *
      * This method retrieves validation violations from your app.
@@ -5422,6 +5798,35 @@ declare const provideHandlers$1: ServicePluginDefinition<{
     getValidationViolations(payload: GetValidationViolationsEnvelope): GetValidationViolationsResponse | Promise<GetValidationViolationsResponse>;
 }>;
 
+type ServicePluginMethodInput = {
+    request: any;
+    metadata: any;
+};
+type ServicePluginContract = Record<string, (payload: ServicePluginMethodInput) => unknown | Promise<unknown>>;
+type ServicePluginMethodMetadata = {
+    name: string;
+    primaryHttpMappingPath: string;
+    transformations: {
+        fromREST: (...args: unknown[]) => ServicePluginMethodInput;
+        toREST: (...args: unknown[]) => unknown;
+    };
+};
+type ServicePluginDefinition<Contract extends ServicePluginContract> = {
+    __type: 'service-plugin-definition';
+    componentType: string;
+    methods: ServicePluginMethodMetadata[];
+    __contract: Contract;
+};
+declare function ServicePluginDefinition<Contract extends ServicePluginContract>(componentType: string, methods: ServicePluginMethodMetadata[]): ServicePluginDefinition<Contract>;
+type BuildServicePluginDefinition<T extends ServicePluginDefinition<any>> = (implementation: T['__contract']) => void;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
 declare function createServicePluginModule<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): BuildServicePluginDefinition<T> & T;
 
 type _publicProvideHandlersType = typeof provideHandlers$1;