@droz-js/sdk 0.1.2

package/README.md

@@ -0,0 +1,44 @@
+# @droz-js/sdk
+
+## Setup (required)
+
+To set up the sdk you need to tell the tenant and the authentication method, the tenant is required. You must run this
+first before making any sdk calls. The sdk will fail if you don't set up the tenant.
+
+```typescript
+import { DrozSdk } from '@droz-js/sdk';
+
+DrozSdk.forTenant('dev').withAuthentication('Basic', 'username', 'password');
+```
+
+You can also split the setup in two steps
+
+```typescript
+import { DrozSdk } from '@droz-js/sdk';
+
+// first step (required)
+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');
+```
+
+## Sample Sdks
+
+### Droz Nexo
+
+```typescript
+import { DrozNexo } from '@droz-js/sdk/droznexo';
+
+const nexo = new DrozNexo();
+const res = await nexo.getAgent({ id: 'agentId' });
+```
+
+### Droz Chat
+
+```typescript
+import { DrozChat } from '@droz-js/sdk/drozchat';
+
+const chat = new DrozChat();
+const res = await chat.listTicketsMine();
+```

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@droz-js/sdk",
+  "description": "Droz SDK",
+  "version": "0.1.2",
+  "private": false,
+  "exports": {
+    ".": "./src/index.js",
+    "./*": "./src/*.js",
+    "./server": "./src/index.ts",
+    "./server/*": "./src/*.ts"
+  },
+  "scripts": {
+    "clean": "npx rimraf src/*.js src/*.d.ts src/**/*.js src/**/*.d.ts",
+    "prebuild": "npm run clean",
+    "build": "tsc --project tsconfig-build.json",
+    "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",
+    "zen-observable": "^0.10.0"
+  },
+  "files": [
+    "package.json",
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "README.md"
+  ]
+}

package/src/client/config.d.ts

@@ -0,0 +1,19 @@
+declare class DrozSdkConfig {
+    authentication?: string;
+    tenant?: string;
+    private initialized;
+    private instances;
+    setTenant(tenant: string): void;
+    setAuthentication(type?: string, ...values: string[]): void;
+    get(): Promise<this>;
+    getEndpoint(serviceName: string, type?: 'http' | 'ws'): string;
+    private reset;
+    private initialize;
+}
+export declare class DrozSdk {
+    private static readonly singleton;
+    static forTenant(tenant: string): typeof DrozSdk;
+    static withAuthentication(type?: string, ...values: string[]): void;
+    static config(): Promise<DrozSdkConfig>;
+}
+export {};

package/src/client/config.js

@@ -0,0 +1,68 @@
+"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;
+    tenant;
+    // internal state
+    initialized = false;
+    instances = [];
+    setTenant(tenant) {
+        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();
+    }
+    getEndpoint(serviceName, type = 'http') {
+        const serviceId = serviceName.replace('@droz/', '');
+        const instance = this.instances.find(instance => {
+            return instance.serviceId == serviceId && instance.type == type;
+        });
+        if (instance)
+            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;
+        const data = await fetch(`${discoveryEndpoint}/discover/${this.tenant}`);
+        const json = await data.json();
+        this.instances = json.instances;
+        return this;
+    }
+}
+class DrozSdk {
+    static singleton = new DrozSdkConfig();
+    static forTenant(tenant) {
+        this.singleton.setTenant(tenant);
+        return this;
+    }
+    static withAuthentication(type, ...values) {
+        this.singleton.setAuthentication(type, ...values);
+    }
+    static async config() {
+        return await this.singleton.get();
+    }
+}
+exports.DrozSdk = DrozSdk;

package/src/client/http.d.ts

@@ -0,0 +1,4 @@
+import Observable from 'zen-observable';
+type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export declare function HttpClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk, any>) => Sdk): new () => Sdk;
+export {};

package/src/client/http.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientBuilder = void 0;
+const zen_observable_1 = require("zen-observable");
+const config_1 = require("./config");
+function buildRequestInfo(req) {
+    const operationNames = Array.isArray(req) ? req.map(r => r.operationName) : [req.operationName];
+    return [...new Set(operationNames)].join(',');
+}
+function onResponse(response) {
+    if (response && 'stack' in response && 'message' in response)
+        throw response;
+    function intercept(r) {
+        if (r.errors)
+            console.error(JSON.stringify(r.errors));
+        return r.data;
+    }
+    if (Array.isArray(response))
+        return response.map(intercept);
+    return intercept(response);
+}
+class HttpSdkRequesterBuilder {
+    serviceName;
+    constructor(serviceName) {
+        this.serviceName = serviceName;
+    }
+    build() {
+        return this.requester.bind(this);
+    }
+    requester(query, variables) {
+        // subscriptions are not executable with the http sdk
+        if (query.match(/subscription .*{/))
+            return zen_observable_1.default.of();
+        // 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(onResponse);
+    }
+    // @InBatches({ maxBatchSize: 12 })
+    async inbatches(request) {
+        const config = await config_1.DrozSdk.config();
+        const endpoint = config.getEndpoint(this.serviceName, 'http');
+        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()),
+            body
+        });
+        // treat the response
+        return await response.json();
+    }
+}
+function HttpClientBuilder(serviceName, getSdk) {
+    class Client {
+        constructor() {
+            const http = new HttpSdkRequesterBuilder(serviceName);
+            const sdk = getSdk(http.build());
+            Object.assign(this, sdk);
+        }
+    }
+    return Client;
+}
+exports.HttpClientBuilder = HttpClientBuilder;

package/src/client/ws.d.ts

@@ -0,0 +1,4 @@
+import Observable from 'zen-observable';
+type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export declare function WsClientBuilder<Sdk>(serviceName: string, getSdk: (requester: Requester<Sdk, any>) => Sdk): new () => Sdk;
+export {};

package/src/client/ws.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClientBuilder = void 0;
+const graphql_ws_1 = require("graphql-ws");
+const zen_observable_1 = require("zen-observable");
+const config_1 = require("./config");
+class WsSdkRequesterBuilder {
+    serviceName;
+    _client;
+    constructor(serviceName) {
+        this.serviceName = serviceName;
+    }
+    build() {
+        return this.requester.bind(this);
+    }
+    async requester(query, variables) {
+        const client = await this.getClient();
+        const isSubscription = query.trim().startsWith('subscription ');
+        const operation = { query, variables };
+        if (isSubscription) {
+            return new zen_observable_1.default((observer) => {
+                return client.subscribe(operation, {
+                    next: response => {
+                        if (response.errors)
+                            console.error(response.errors);
+                        observer.next(response.data);
+                    },
+                    error: error => observer.error(error),
+                    complete: () => observer.complete()
+                });
+            });
+        }
+        return new Promise((resolve, reject) => {
+            client.subscribe(operation, {
+                next: response => {
+                    if (response.errors)
+                        console.error(response.errors);
+                    resolve(response.data);
+                },
+                error: error => reject(error),
+                complete: () => void 0
+            });
+        });
+    }
+    async getClient() {
+        if (this._client)
+            return this._client;
+        const config = await config_1.DrozSdk.config();
+        const endpoint = config.getEndpoint(this.serviceName, 'ws');
+        this._client = (0, graphql_ws_1.createClient)({
+            url: endpoint,
+            lazy: true,
+            retryAttempts: 128,
+            keepAlive: 25000,
+            connectionParams: {
+                authorization: config.authentication
+            }
+        });
+        return this._client;
+    }
+}
+function WsClientBuilder(serviceName, getSdk) {
+    class Client {
+        constructor() {
+            const http = new WsSdkRequesterBuilder(serviceName);
+            const sdk = getSdk(http.build());
+            Object.assign(this, sdk);
+        }
+    }
+    return Client;
+}
+exports.WsClientBuilder = WsClientBuilder;

package/src/drozbot.d.ts

@@ -0,0 +1,20 @@
+export * from './sdks/drozbot';
+declare const DrozBot_base: new () => {
+    getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;
+    listDrozBotInstances(variables?: import("./sdks/drozbot").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").ListDrozBotInstancesQuery>;
+    createDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").CreateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").CreateDrozBotInstanceMutation>;
+    updateDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").UpdateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").UpdateDrozBotInstanceMutation>;
+    removeDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").RemoveDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").RemoveDrozBotInstanceMutation>;
+};
+export declare class DrozBot extends DrozBot_base {
+}

package/src/drozbot.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrozBot = void 0;
+const http_1 = require("./client/http");
+const drozbot_1 = require("./sdks/drozbot");
+__exportStar(require("./sdks/drozbot"), exports);
+class DrozBot extends (0, http_1.HttpClientBuilder)(drozbot_1.serviceName, drozbot_1.getSdk) {
+}
+exports.DrozBot = DrozBot;

package/src/drozchat-ws.d.ts

@@ -0,0 +1,18 @@
+export * from './sdks/drozchat';
+export declare const DrozChatWs: new () => {
+    getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;
+    listDrozBotInstances(variables?: import("./sdks/drozbot").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").ListDrozBotInstancesQuery>;
+    createDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").CreateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").CreateDrozBotInstanceMutation>;
+    updateDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").UpdateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").UpdateDrozBotInstanceMutation>;
+    removeDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").RemoveDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").RemoveDrozBotInstanceMutation>;
+};

package/src/drozchat-ws.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrozChatWs = void 0;
+const ws_1 = require("./client/ws");
+const drozbot_1 = require("./sdks/drozbot");
+__exportStar(require("./sdks/drozchat"), exports);
+exports.DrozChatWs = (0, ws_1.WsClientBuilder)(drozbot_1.serviceName, drozbot_1.getSdk);

package/src/drozchat.d.ts

@@ -0,0 +1,20 @@
+export * from './sdks/drozchat';
+declare const DrozChat_base: new () => {
+    getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;
+    listDrozBotInstances(variables?: import("./sdks/drozbot").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").ListDrozBotInstancesQuery>;
+    createDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").CreateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").CreateDrozBotInstanceMutation>;
+    updateDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").UpdateDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").UpdateDrozBotInstanceMutation>;
+    removeDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+        input: import("./sdks/drozbot").RemoveDrozBotInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/drozbot").RemoveDrozBotInstanceMutation>;
+};
+export declare class DrozChat extends DrozChat_base {
+}

package/src/drozchat.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrozChat = void 0;
+const http_1 = require("./client/http");
+const drozbot_1 = require("./sdks/drozbot");
+__exportStar(require("./sdks/drozchat"), exports);
+class DrozChat extends (0, http_1.HttpClientBuilder)(drozbot_1.serviceName, drozbot_1.getSdk) {
+}
+exports.DrozChat = DrozChat;

package/src/droznexo.d.ts

@@ -0,0 +1,18 @@
+export * from './sdks/droznexo';
+export declare const DrozNexo: new () => {
+    createAgent(variables: import("./sdks/droznexo").Exact<{
+        input: import("./sdks/droznexo").CreateAgentInput;
+    }>, options?: unknown): Promise<import("./sdks/droznexo").CreateAgentMutation>;
+    listAgents(variables?: import("./sdks/droznexo").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/droznexo").ListAgentsQuery>;
+    getAgent(variables: import("./sdks/droznexo").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/droznexo").GetAgentQuery>;
+    createAgentGroup(variables: import("./sdks/droznexo").Exact<{
+        input: import("./sdks/droznexo").CreateAgentGroupInput;
+    }>, options?: unknown): Promise<import("./sdks/droznexo").CreateAgentGroupMutation>;
+    listAgentGroups(variables?: import("./sdks/droznexo").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/droznexo").ListAgentGroupsQuery>;
+};

package/src/droznexo.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrozNexo = void 0;
+const http_1 = require("./client/http");
+const droznexo_1 = require("./sdks/droznexo");
+__exportStar(require("./sdks/droznexo"), exports);
+exports.DrozNexo = (0, http_1.HttpClientBuilder)(droznexo_1.serviceName, droznexo_1.getSdk);

package/src/index.d.ts

@@ -0,0 +1 @@
+export { DrozSdk } from './client/config';

package/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrozSdk = void 0;
+var config_1 = require("./client/config");
+Object.defineProperty(exports, "DrozSdk", { enumerable: true, get: function () { return config_1.DrozSdk; } });

package/src/nucleus.d.ts

@@ -0,0 +1,68 @@
+export * from './sdks/nucleus';
+export declare const Nucleus: new () => {
+    getApp(variables: import("./sdks/nucleus").Exact<{
+        appId: string;
+        withInstances?: boolean;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetAppQuery>;
+    getApps(variables?: import("./sdks/nucleus").Exact<{
+        type?: import("./sdks/nucleus").AppType;
+        withInstances?: boolean;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetAppsQuery>;
+    listAppInstances(variables?: import("./sdks/nucleus").Exact<{
+        appId?: string;
+        appType?: import("./sdks/nucleus").AppType;
+        withApp?: boolean;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListAppInstancesQuery>;
+    getCredentials(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetCredentialsQuery>;
+    getCredentialsSecret(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetCredentialsSecretQuery>;
+    listCredentials(variables?: import("./sdks/nucleus").Exact<{
+        type?: import("./sdks/nucleus").CredentialsType;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListCredentialsQuery>;
+    createCredentials(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").CreateCredentialsInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").CreateCredentialsMutation>;
+    updateCredentials(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").UpdateCredentialsInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").UpdateCredentialsMutation>;
+    removeCredentials(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").RemoveCredentialsInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").RemoveCredentialsMutation>;
+    getCronJob(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetCronJobQuery>;
+    listCronJobs(variables?: import("./sdks/nucleus").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ListCronJobsQuery>;
+    createCronJob(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").CreateCronJobInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").CreateCronJobMutation>;
+    updateCronJob(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").UpdateCronJobInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").UpdateCronJobMutation>;
+    removeCronJob(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").RemoveCronJobInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").RemoveCronJobMutation>;
+    resolveSession(variables: import("./sdks/nucleus").Exact<{
+        sessionId?: string;
+        userId?: string;
+        triggerDrn: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").ResolveSessionQuery>;
+    getSessionData(variables: import("./sdks/nucleus").Exact<{
+        sessionId: string;
+        namespace?: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetSessionDataQuery>;
+    setSessionData(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").SetSessionDataInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").SetSessionDataMutation>;
+    patchSessionData(variables: import("./sdks/nucleus").Exact<{
+        input: import("./sdks/nucleus").PatchSessionDataInput;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").PatchSessionDataMutation>;
+    getStateMachine(variables: import("./sdks/nucleus").Exact<{
+        id: string;
+        versionId: string;
+    }>, options?: unknown): Promise<import("./sdks/nucleus").GetStateMachineQuery>;
+};

package/src/nucleus.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nucleus = void 0;
+const http_1 = require("./client/http");
+const nucleus_1 = require("./sdks/nucleus");
+__exportStar(require("./sdks/nucleus"), exports);
+exports.Nucleus = (0, http_1.HttpClientBuilder)(nucleus_1.serviceName, nucleus_1.getSdk);

package/src/reclameaqui.d.ts

@@ -0,0 +1,20 @@
+export * from './sdks/reclameaqui';
+declare const Reclameaqui_base: new () => {
+    getReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/reclameaqui").GetReclameAquiInstanceQuery>;
+    listReclameAquiInstances(variables?: import("./sdks/reclameaqui").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/reclameaqui").ListReclameAquiInstancesQuery>;
+    createReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
+        input: import("./sdks/reclameaqui").CreateReclameAquiInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/reclameaqui").CreateReclameAquiInstanceMutation>;
+    updateReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
+        input: import("./sdks/reclameaqui").UpdateReclameAquiInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/reclameaqui").UpdateReclameAquiInstanceMutation>;
+    removeReclameAquiInstance(variables: import("./sdks/reclameaqui").Exact<{
+        input: import("./sdks/reclameaqui").RemoveReclameAquiInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/reclameaqui").RemoveReclameAquiInstanceMutation>;
+};
+export declare class Reclameaqui extends Reclameaqui_base {
+}

package/src/reclameaqui.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reclameaqui = void 0;
+const http_1 = require("./client/http");
+const reclameaqui_1 = require("./sdks/reclameaqui");
+__exportStar(require("./sdks/reclameaqui"), exports);
+class Reclameaqui extends (0, http_1.HttpClientBuilder)(reclameaqui_1.serviceName, reclameaqui_1.getSdk) {
+}
+exports.Reclameaqui = Reclameaqui;