@droz-js/sdk 0.2.1 → 0.2.3

package/README.md

@@ -8,7 +8,7 @@ first before making any sdk calls. The sdk will fail if you don't set up the ten
 ```typescript
 import { DrozSdk } from '@droz-js/sdk';
 
-DrozSdk.forTenant('dev').withAuthentication('Basic', 'username', 'password');
+DrozSdk.forTenant('dev').withAuthorization('Basic', 'username', 'password');
 ```
 
 You can also split the setup in two steps
@@ -20,7 +20,7 @@ import { DrozSdk } from '@droz-js/sdk';
 DrozSdk.forTenant('dev');
 
 // (optional) later when you have the authentication token you can set it and it will automatically be used in the new requests
-DrozSdk.withAuthentication('Basic', 'username', 'password');
+DrozSdk.withAuthorization('Basic', 'username', 'password');
 ```
 
 ## Websocket

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@droz-js/sdk",
   "description": "Droz SDK",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "private": false,
   "exports": {
     ".": "./src/index.js",
@@ -16,9 +16,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "cross-fetch": "^3.1.8",
     "graphql": "^16.8.1",
-    "graphql-tag": "^2.12.6",
     "graphql-ws": "^5.14.1",
     "inbatches": "^0.0.10"
   },

package/src/client/config.d.ts

@@ -1,19 +1,29 @@
-declare class DrozSdkConfig {
-    authentication?: string;
-    tenant?: string;
-    private initialized;
-    private instances;
-    setTenant(tenant: string): void;
-    setAuthentication(type?: string, ...values: string[]): void;
-    get(): Promise<this>;
+import { AuthorizationProvider } from './helpers';
+export interface Service {
+    tenantId: string;
+    serviceId: string;
+    type: string;
+    endpoint: string;
+}
+declare class TenantConfig {
+    readonly tenant: string;
+    private readonly services;
+    constructor(tenant: string, instances: Service[]);
     getEndpoint(serviceName: string, type?: 'http' | 'ws'): string;
-    private reset;
-    private initialize;
 }
+/**
+ * The DrozSdk is the entry point for the SDK. It allows to configure the default tenant and authorization provider.
+ */
 export declare class DrozSdk {
-    private static readonly singleton;
+    private static defaultTenant?;
+    private static defaultAuthorizationProvider?;
+    private static readonly tenantConfigs;
     static forTenant(tenant: string): typeof DrozSdk;
-    static withAuthentication(type?: string, ...values: string[]): void;
-    static config(): Promise<DrozSdkConfig>;
+    static withAuthorization(type?: string, ...values: string[]): void;
+    static withAuthorizationProvider(provider: () => Promise<string>): void;
+    static getAuthorization(customProvider?: AuthorizationProvider): Promise<string>;
+    static getTenantConfig(customTenant?: string): Promise<TenantConfig>;
+    private static getOrDiscoverTenantConfig;
+    private static discoverTenantConfig;
 }
 export {};

package/src/client/config.js

@@ -1,39 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DrozSdk = void 0;
-const discoveryEndpoint = 'https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws';
-class DrozSdkConfig {
-    authentication;
+const helpers_1 = require("./helpers");
+class TenantConfig {
     tenant;
-    // internal state
-    initialized = false;
-    instances = [];
-    setTenant(tenant) {
+    services;
+    constructor(tenant, instances) {
         this.tenant = tenant;
-        this.reset();
-    }
-    setAuthentication(type, ...values) {
-        if (!['Bearer', 'Basic'].includes(type)) {
-            throw new Error(`Invalid authentication type ${type}`);
-        }
-        if (values.length && values.every(Boolean)) {
-            if (type == 'Basic')
-                this.authentication = `Basic ${Buffer.from(values.join(':')).toString('base64')}`;
-            if (type == 'Bearer')
-                this.authentication = `Bearer ${values[0]}`;
-        }
-        else {
-            this.authentication = undefined;
-        }
-    }
-    async get() {
-        if (this.initialized)
-            return this;
-        return await this.initialize();
+        this.services = instances;
     }
     getEndpoint(serviceName, type = 'http') {
         const serviceId = serviceName.replace('@droz/', '');
-        const instance = this.instances.find(instance => {
+        const instance = this.services.find(instance => {
             return instance.serviceId == serviceId && instance.type == type;
         });
         if (instance) {
@@ -44,36 +22,59 @@ class DrozSdkConfig {
             }
             return instance.endpoint;
         }
-        throw new Error(`Endpoint for ${serviceId} and type ${type} not found`);
-    }
-    reset() {
-        this.initialized = false;
-        this.instances = [];
-    }
-    async initialize() {
-        this.initialized = true;
-        // fetch instances from discovery service
-        const data = await fetch(`${discoveryEndpoint}/discover/${this.tenant}`);
-        const json = await data.json();
-        this.instances = json.instances ?? [];
-        // validate it's a valid tenant
-        if (this.instances.length === 0) {
-            throw new Error(`Invalid tenant '${this.tenant}', no instances found`);
-        }
-        return this;
+        throw new Error(`Tenant "${this.tenant}" endpoint for service "${serviceId}" and type "${type}" not found`);
     }
 }
+/**
+ * The DrozSdk is the entry point for the SDK. It allows to configure the default tenant and authorization provider.
+ */
 class DrozSdk {
-    static singleton = new DrozSdkConfig();
+    static defaultTenant;
+    static defaultAuthorizationProvider;
+    static tenantConfigs = new Map();
     static forTenant(tenant) {
-        this.singleton.setTenant(tenant);
+        this.defaultTenant = tenant;
+        this.tenantConfigs.delete(tenant);
         return this;
     }
-    static withAuthentication(type, ...values) {
-        this.singleton.setAuthentication(type, ...values);
+    static withAuthorization(type, ...values) {
+        this.defaultAuthorizationProvider = (0, helpers_1.toAuthorizationProvider)(type, ...values);
+    }
+    static withAuthorizationProvider(provider) {
+        this.defaultAuthorizationProvider = provider;
+    }
+    static async getAuthorization(customProvider) {
+        if (customProvider)
+            return await (0, helpers_1.resolveAuthorization)(customProvider);
+        const defaultProvider = this.defaultAuthorizationProvider;
+        if (defaultProvider)
+            return await (0, helpers_1.resolveAuthorization)(defaultProvider);
+    }
+    static async getTenantConfig(customTenant) {
+        if (customTenant)
+            return await this.getOrDiscoverTenantConfig(customTenant);
+        const defaultTenant = this.defaultTenant;
+        return this.getOrDiscoverTenantConfig(defaultTenant);
+    }
+    static async getOrDiscoverTenantConfig(tenant) {
+        if (this.tenantConfigs.has(tenant)) {
+            return this.tenantConfigs.get(tenant);
+        }
+        return await this.discoverTenantConfig(tenant);
     }
-    static async config() {
-        return await this.singleton.get();
+    static async discoverTenantConfig(tenant) {
+        // fetch instances from discovery service
+        const data = await fetch(`${helpers_1.serviceDiscoveryEndpoint}/discover/${tenant}`);
+        const json = await data.json();
+        const instances = json.instances ?? [];
+        // validate it's a valid tenant
+        if (instances.length === 0) {
+            throw new Error(`Invalid tenant '${tenant}', no instances found on service discovery`);
+        }
+        // create tenant config and cache it
+        const config = new TenantConfig(tenant, instances);
+        this.tenantConfigs.set(tenant, config);
+        return config;
     }
 }
 exports.DrozSdk = DrozSdk;

package/src/client/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionResult } from 'graphql';
+export declare const serviceDiscoveryEndpoint = "https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws";
+export type AuthorizationProvider = string | (() => Promise<string>) | (() => string);
+export type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterableIterator<R>;
+export type GetSdk<Sdk> = (requester: Requester<Sdk>) => Sdk;
+export declare function toAuthorizationProvider(type?: string, ...values: string[]): AuthorizationProvider;
+export declare function resolveAuthorization(provider?: AuthorizationProvider): Promise<string>;
+export declare function mapGraphqlResponse<T>(response: ExecutionResult<T> | Error): T;
+export declare function mapAsyncIterableGraphqlResponse<T>(iterable: AsyncIterableIterator<ExecutionResult<T, any>>): AsyncGenerator<Awaited<T>, void, unknown>;

package/src/client/helpers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsyncIterableGraphqlResponse = exports.mapGraphqlResponse = exports.resolveAuthorization = exports.toAuthorizationProvider = exports.serviceDiscoveryEndpoint = void 0;
+exports.serviceDiscoveryEndpoint = 'https://th3xrek4rane2scfwwfoo7wemq0tvuzm.lambda-url.sa-east-1.on.aws';
+function toAuthorizationProvider(type, ...values) {
+    // this means it is unsetting the authorization token
+    if (!type)
+        return undefined;
+    if (!values.every(Boolean))
+        return undefined;
+    if (type == 'Basic') {
+        const base64 = Buffer.from(values.join(':')).toString('base64');
+        return `Basic ${base64}`;
+    }
+    if (type == 'Bearer') {
+        return `Bearer ${values[0]}`;
+    }
+    throw new Error(`Invalid authentication type '${type}'`);
+}
+exports.toAuthorizationProvider = toAuthorizationProvider;
+async function resolveAuthorization(provider) {
+    if (typeof provider === 'string')
+        return provider;
+    if (typeof provider === 'function')
+        return await provider();
+    return undefined;
+}
+exports.resolveAuthorization = resolveAuthorization;
+function mapGraphqlResponse(response) {
+    if (response) {
+        if (response && 'stack' in response && 'message' in response)
+            throw response;
+        if ('errors' in response)
+            console.error(JSON.stringify(response.errors));
+        if ('data' in response)
+            return response.data;
+    }
+}
+exports.mapGraphqlResponse = mapGraphqlResponse;
+async function* mapAsyncIterableGraphqlResponse(iterable) {
+    for await (const each of iterable) {
+        yield mapGraphqlResponse(each);
+    }
+}
+exports.mapAsyncIterableGraphqlResponse = mapAsyncIterableGraphqlResponse;

package/src/client/http.d.ts

@@ -1,6 +1,6 @@
-export declare const emptyAsyncIterator: <R>() => {
-    [Symbol.asyncIterator](): AsyncIterator<R, any, undefined>;
-};
-type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
-export declare function HttpClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk>) => Sdk): new () => Sdk;
-export {};
+import { AuthorizationProvider, GetSdk } from './helpers';
+export declare function HttpClientBuilder<Sdk>(serviceName: string, getSdk: GetSdk<Sdk>): new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: AuthorizationProvider): void;
+} & Sdk;

package/src/client/http.js

@@ -9,49 +9,71 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpClientBuilder = exports.emptyAsyncIterator = void 0;
+exports.HttpClientBuilder = void 0;
 const inbatches_1 = require("inbatches");
 const config_1 = require("./config");
-const utils_1 = require("./utils");
-const emptyAsyncIterator = () => ({
-    async *[Symbol.asyncIterator]() { }
-});
-exports.emptyAsyncIterator = emptyAsyncIterator;
+const helpers_1 = require("./helpers");
+// create an empty AsyncIterableIterator
+function emptyAsyncIterator() {
+    return {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        async next() {
+            return { done: true, value: undefined };
+        }
+    };
+}
 function buildRequestInfo(req) {
     const operationNames = Array.isArray(req) ? req.map(r => r.operationName) : [req.operationName];
     return [...new Set(operationNames)].join(',');
 }
-class HttpSdkRequesterBuilder {
+class HttpRequester {
     serviceName;
+    tenant;
+    authorization;
     constructor(serviceName) {
         this.serviceName = serviceName;
     }
+    forTenant(tenant) {
+        this.tenant = tenant;
+    }
+    withAuthorization(authorization) {
+        this.authorization = authorization;
+    }
     build() {
         return this.requester.bind(this);
     }
     requester(query, variables) {
         // subscriptions are not executable with the http sdk
         if (query.match(/subscription .*{/))
-            return (0, exports.emptyAsyncIterator)();
+            return emptyAsyncIterator();
         // extract operation name and enqueue the request to be executed in batches
         const operationName = /(?:query|mutation) ([^({ ]*)/.exec(query)?.[1];
-        return this.inbatches({ query, variables, operationName }).then(utils_1.mapGraphqlResponse);
+        return this.inbatches({ query, variables, operationName }).then(helpers_1.mapGraphqlResponse);
+    }
+    async buildRequest() {
+        const [authorization, tenant] = await Promise.all([
+            config_1.DrozSdk.getAuthorization(this.authorization),
+            config_1.DrozSdk.getTenantConfig(this.tenant)
+        ]);
+        const endpoint = tenant.getEndpoint(this.serviceName);
+        const heads = new Headers();
+        heads.set('Authorization', authorization);
+        heads.set('Content-Type', 'application/json');
+        const headers = Object.fromEntries(heads.entries());
+        return { endpoint, headers };
     }
     async inbatches(request) {
-        const config = await config_1.DrozSdk.config();
-        const endpoint = config.getEndpoint(this.serviceName, 'http');
+        const { endpoint, headers } = await this.buildRequest();
         const body = JSON.stringify(request);
         const args = buildRequestInfo(request);
-        const headers = new Headers();
-        headers.set('Authorization', config.authentication);
-        headers.set('Content-Type', 'application/json');
         // make POST request
         const response = await fetch(`${endpoint}?${args}`, {
             method: 'POST',
-            headers: Object.fromEntries(headers.entries()),
+            headers,
             body
         });
-        // treat the response
         return await response.json();
     }
 }
@@ -60,14 +82,21 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], HttpSdkRequesterBuilder.prototype, "inbatches", null);
+], HttpRequester.prototype, "inbatches", null);
 function HttpClientBuilder(serviceName, getSdk) {
     class Client {
+        http; // cannot type as HttpSdkRequesterBuilder because it is an anonymous class
         constructor() {
-            const http = new HttpSdkRequesterBuilder(serviceName);
-            const sdk = getSdk(http.build());
+            this.http = new HttpRequester(serviceName);
+            const sdk = getSdk(this.http.build());
             Object.assign(this, sdk);
         }
+        forTenant(tenant) {
+            this.http.forTenant(tenant);
+        }
+        withAuthorization(authorization) {
+            this.http.withAuthorization(authorization);
+        }
     }
     return Client;
 }

package/src/client/ws.d.ts

@@ -1,7 +1,5 @@
-import { Client } from 'graphql-ws';
-type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
-type Connect = {
-    connect(): Promise<Client>;
-};
-export declare function WsClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk>) => Sdk): new () => Sdk & Connect;
-export {};
+import { GetSdk } from './helpers';
+export declare function WsClientBuilder<Sdk>(serviceName: string, getSdk: GetSdk<Sdk>): new () => {
+    readonly ws: any;
+    connect(): Promise<any>;
+} & Sdk;

package/src/client/ws.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsClientBuilder = void 0;
 const graphql_ws_1 = require("graphql-ws");
 const config_1 = require("./config");
-const utils_1 = require("./utils");
-class WsSdkRequesterBuilder {
+const helpers_1 = require("./helpers");
+class WsRequester {
     serviceName;
     client;
     constructor(serviceName) {
@@ -13,16 +13,17 @@ class WsSdkRequesterBuilder {
     async connect() {
         if (this.client)
             return this.client;
-        const config = await config_1.DrozSdk.config();
-        const endpoint = config.getEndpoint(this.serviceName, 'ws');
+        const [tenant, authorization] = await Promise.all([
+            config_1.DrozSdk.getTenantConfig(),
+            config_1.DrozSdk.getAuthorization()
+        ]);
+        const endpoint = tenant.getEndpoint(this.serviceName, 'ws');
         this.client = (0, graphql_ws_1.createClient)({
             url: endpoint,
             lazy: true,
             retryAttempts: 128,
             keepAlive: 25000,
-            connectionParams: {
-                authorization: config.authentication
-            }
+            connectionParams: { authorization }
         });
         return this.client;
     }
@@ -37,20 +38,20 @@ class WsSdkRequesterBuilder {
         const iterable = this.client.iterate(operation);
         // subscription
         if (isSubscription) {
-            return (0, utils_1.mapAsyncIterableGraphqlResponse)(iterable);
+            return (0, helpers_1.mapAsyncIterableGraphqlResponse)(iterable);
         }
         // single query or mutation
         return iterable
             .next()
             .then(one => one.value)
-            .then(res => (0, utils_1.mapGraphqlResponse)(res));
+            .then(res => (0, helpers_1.mapGraphqlResponse)(res));
     }
 }
 function WsClientBuilder(serviceName, getSdk) {
     class Client {
-        ws;
+        ws; // cannot type as WsSdkRequester because it is an anonymous class
         constructor() {
-            this.ws = new WsSdkRequesterBuilder(serviceName);
+            this.ws = new WsRequester(serviceName);
             const sdk = getSdk(this.ws.build());
             Object.assign(this, sdk);
         }

package/src/drozbot.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/drozbot';
 export declare const DrozBot: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;

package/src/drozchat-ws.d.ts

@@ -1,5 +1,8 @@
 export * from './sdks/drozchat';
 export declare const DrozChatWs: new () => {
+    readonly ws: any;
+    connect(): Promise<any>;
+} & {
     createCustomer(variables: import("./sdks/drozchat").Exact<{
         input: import("./sdks/drozchat").CreateCustomerInput;
     }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;
@@ -66,6 +69,4 @@ export declare const DrozChatWs: new () => {
     onTicketMessage(variables: import("./sdks/drozchat").Exact<{
         ticketId: string;
     }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketMessageSubscription>;
-} & {
-    connect(): Promise<import("graphql-ws").Client>;
 };

package/src/drozchat.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/drozchat';
 export declare const DrozChat: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     createCustomer(variables: import("./sdks/drozchat").Exact<{
         input: import("./sdks/drozchat").CreateCustomerInput;
     }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;

package/src/droznexo.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/droznexo';
 export declare const DrozNexo: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     createAgent(variables: import("./sdks/droznexo").Exact<{
         input: import("./sdks/droznexo").CreateAgentInput;
     }>, options?: unknown): Promise<import("./sdks/droznexo").CreateAgentMutation>;

package/src/mercadolivre.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/mercadolivre';
 export declare const MercadoLivre: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/mercadolivre").GetMercadoLivreInstanceQuery>;

package/src/nucleus.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/nucleus';
 export declare const Nucleus: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getApp(variables: import("./sdks/nucleus").Exact<{
         appId: string;
         withInstances?: boolean;
@@ -65,4 +69,41 @@ export declare const Nucleus: new () => {
         id: string;
         versionId: string;
     }>, options?: unknown): Promise<import("./sdks/nucleus").GetStateMachineQuery>;
+    listLiveStateMachineConfigs(variables?: import("./sdks/nucleus").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListLiveStateMachineConfigsQuery>;
+    listDraftStateMachineConfigs(variables?: import("./sdks/nucleus").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListDraftStateMachineConfigsQuery>;
+    listStateMachineConfigVersions(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListStateMachineConfigVersionsQuery>;
+    getXStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+        versionId: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetXStateMachineConfigQuery>;
+    createStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").CreateStateMachineConfigInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").CreateStateMachineConfigMutation>;
+    updateStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").UpdateStateMachineConfigInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").UpdateStateMachineConfigMutation>;
+    removeStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").RemoveStateMachineConfigInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").RemoveStateMachineConfigMutation>;
+    editStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").EditStateMachineConfigInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").EditStateMachineConfigMutation>;
+    publishStateMachineConfig(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").PublishStateMachineConfigInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").PublishStateMachineConfigMutation>;
+    createStateMachineConfigState(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").CreateStateMachineConfigStateInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").CreateStateMachineConfigStateMutation>;
+    updateStateMachineConfigState(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").UpdateStateMachineConfigStateInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").UpdateStateMachineConfigStateMutation>;
+    removeStateMachineConfigState(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").RemoveStateMachineConfigStateInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").RemoveStateMachineConfigStateMutation>;
 };

package/src/reclameaqui.d.ts

@@ -1,5 +1,9 @@
 export * from './sdks/reclameaqui';
 export declare const Reclameaqui: new () => {
+    readonly http: any;
+    forTenant(tenant: string): void;
+    withAuthorization(authorization: import("./client/helpers").AuthorizationProvider): void;
+} & {
     getReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
         id: string;
     }>, options?: unknown): Promise<import("./sdks/reclameaqui").GetReclameAquiInstanceQuery>;

package/src/sdks/drozbot.d.ts

@@ -70,8 +70,8 @@ export type Scalars = {
         output: any;
     };
     Set: {
-        input: any;
-        output: any;
+        input: Set<any>;
+        output: any[];
     };
     URL: {
         input: string;
@@ -115,6 +115,7 @@ export type PageInfo = {
 export type Query = {
     app?: Maybe<Scalars['DRN']['output']>;
     getDrozBotInstance?: Maybe<DrozBotInstance>;
+    getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     listDrozBotInstances: Array<Maybe<DrozBotInstance>>;
     version?: Maybe<Scalars['String']['output']>;
 };
@@ -124,9 +125,6 @@ export type QueryGetDrozBotInstanceArgs = {
 export type RemoveDrozBotInstanceInput = {
     id: Scalars['ID']['input'];
 };
-export type Subscription = {
-    version?: Maybe<Scalars['String']['output']>;
-};
 export declare enum Typenames {
     Any = "Any",
     DrozBotInstance = "DrozBotInstance",