@droz-js/sdk 0.1.4 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@droz-js/sdk",
   "description": "Droz SDK",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "private": false,
   "exports": {
     ".": "./src/index.js",
@@ -20,8 +20,10 @@
     "graphql": "^16.8.1",
     "graphql-tag": "^2.12.6",
     "graphql-ws": "^5.14.1",
-    "inbatches": "^0.0.10",
-    "zen-observable": "^0.10.0"
+    "inbatches": "^0.0.10"
+  },
+  "devDependencies": {
+    "mock-socket": "^9.3.1"
   },
   "files": [
     "package.json",

package/src/client/config.js

@@ -52,9 +52,14 @@ class DrozSdkConfig {
     }
     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;
+        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;
     }
 }

package/src/client/http.d.ts

@@ -1,4 +1,6 @@
-import Observable from 'zen-observable';
-type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+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 {};

package/src/client/http.js

@@ -1,24 +1,26 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 = void 0;
-const zen_observable_1 = require("zen-observable");
+exports.HttpClientBuilder = exports.emptyAsyncIterator = 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;
 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) {
@@ -30,12 +32,11 @@ class HttpSdkRequesterBuilder {
     requester(query, variables) {
         // subscriptions are not executable with the http sdk
         if (query.match(/subscription .*{/))
-            return zen_observable_1.default.of();
+            return (0, exports.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(onResponse);
+        return this.inbatches({ query, variables, operationName }).then(utils_1.mapGraphqlResponse);
     }
-    // @InBatches({ maxBatchSize: 12 })
     async inbatches(request) {
         const config = await config_1.DrozSdk.config();
         const endpoint = config.getEndpoint(this.serviceName, 'http');
@@ -54,6 +55,12 @@ class HttpSdkRequesterBuilder {
         return await response.json();
     }
 }
+__decorate([
+    (0, inbatches_1.InBatches)({ maxBatchSize: 12 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HttpSdkRequesterBuilder.prototype, "inbatches", null);
 function HttpClientBuilder(serviceName, getSdk) {
     class Client {
         constructor() {

package/src/client/utils.d.ts

@@ -0,0 +1,3 @@
+import { ExecutionResult } from 'graphql/index';
+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/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsyncIterableGraphqlResponse = exports.mapGraphqlResponse = void 0;
+function mapGraphqlResponse(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/ws.d.ts

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

package/src/client/ws.js

@@ -2,52 +2,20 @@
 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");
+const utils_1 = require("./utils");
 class WsSdkRequesterBuilder {
     serviceName;
-    _client;
+    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;
+    async connect() {
+        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)({
+        this.client = (0, graphql_ws_1.createClient)({
             url: endpoint,
             lazy: true,
             retryAttempts: 128,
@@ -56,16 +24,39 @@ class WsSdkRequesterBuilder {
                 authorization: config.authentication
             }
         });
-        return this._client;
+        return this.client;
+    }
+    build() {
+        return this.requester.bind(this);
+    }
+    requester(query, variables) {
+        if (!this.client)
+            throw new Error('Client not connected, you must call await client.connect(); first');
+        const isSubscription = query.trim().startsWith('subscription ');
+        const operation = { query, variables };
+        const iterable = this.client.iterate(operation);
+        // subscription
+        if (isSubscription) {
+            return (0, utils_1.mapAsyncIterableGraphqlResponse)(iterable);
+        }
+        // single query or mutation
+        return iterable
+            .next()
+            .then(one => one.value)
+            .then(res => (0, utils_1.mapGraphqlResponse)(res));
     }
 }
 function WsClientBuilder(serviceName, getSdk) {
     class Client {
+        ws;
         constructor() {
-            const http = new WsSdkRequesterBuilder(serviceName);
-            const sdk = getSdk(http.build());
+            this.ws = new WsSdkRequesterBuilder(serviceName);
+            const sdk = getSdk(this.ws.build());
             Object.assign(this, sdk);
         }
+        async connect() {
+            return this.ws.connect();
+        }
     }
     return Client;
 }

package/src/drozchat-ws.d.ts

@@ -1,18 +1,71 @@
 export * from './sdks/drozchat';
 export declare const DrozChatWs: new () => {
-    getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+    createCustomer(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateCustomerInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;
+    updateCustomer(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").UpdateCustomerInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").UpdateCustomerMutation>;
+    listCustomers(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListCustomersQuery>;
+    getCustomer(variables: import("./sdks/drozchat").Exact<{
         id: string;
-    }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;
-    listDrozBotInstances(variables?: import("./sdks/drozbot").Exact<{
+    }>, options?: unknown): Promise<import("./sdks/drozchat").GetCustomerQuery>;
+    getTicket(variables: import("./sdks/drozchat").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").GetTicketQuery>;
+    listTickets(variables: import("./sdks/drozchat").Exact<{
+        state: import("./sdks/drozchat").TicketState;
+        assigneeId?: string;
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsQuery>;
+    listTicketsInQueue(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsInQueueQuery>;
+    listTicketsInProgressMine(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsInProgressMineQuery>;
+    listTicketsClosed(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsClosedQuery>;
+    listTicketMessages(variables: import("./sdks/drozchat").Exact<{
+        ticketId: string;
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketMessagesQuery>;
+    createTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateTicketMutation>;
+    markTicketMessagesAsRead(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").MarkTicketMessagesAsReadInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").MarkTicketMessagesAsReadMutation>;
+    createTicketMessage(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateTicketMessageInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateTicketMessageMutation>;
+    assignTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").AssignTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").AssignTicketMutation>;
+    assignTicketMyself(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").AssignTicketMyselfInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").AssignTicketMyselfMutation>;
+    unassignTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").UnassignTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").UnassignTicketMutation>;
+    closeTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CloseTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CloseTicketMutation>;
+    onTicketInQueue(variables?: import("./sdks/drozchat").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketInQueueSubscription>;
+    onTicketInProgressMine(variables?: import("./sdks/drozchat").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketInProgressMineSubscription>;
+    onTicketClosed(variables?: import("./sdks/drozchat").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>;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketClosedSubscription>;
+    onTicketMessage(variables: import("./sdks/drozchat").Exact<{
+        ticketId: string;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketMessageSubscription>;
+} & {
+    connect(): Promise<import("graphql-ws").Client>;
 };

package/src/drozchat-ws.js

@@ -16,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DrozChatWs = void 0;
 const ws_1 = require("./client/ws");
-const drozbot_1 = require("./sdks/drozbot");
+const drozchat_1 = require("./sdks/drozchat");
 __exportStar(require("./sdks/drozchat"), exports);
-exports.DrozChatWs = (0, ws_1.WsClientBuilder)(drozbot_1.serviceName, drozbot_1.getSdk);
+exports.DrozChatWs = (0, ws_1.WsClientBuilder)(drozchat_1.serviceName, drozchat_1.getSdk);

package/src/drozchat.d.ts

@@ -1,18 +1,69 @@
 export * from './sdks/drozchat';
 export declare const DrozChat: new () => {
-    getDrozBotInstance(variables: import("./sdks/drozbot").Exact<{
+    createCustomer(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateCustomerInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateCustomerMutation>;
+    updateCustomer(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").UpdateCustomerInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").UpdateCustomerMutation>;
+    listCustomers(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListCustomersQuery>;
+    getCustomer(variables: import("./sdks/drozchat").Exact<{
         id: string;
-    }>, options?: unknown): Promise<import("./sdks/drozbot").GetDrozBotInstanceQuery>;
-    listDrozBotInstances(variables?: import("./sdks/drozbot").Exact<{
+    }>, options?: unknown): Promise<import("./sdks/drozchat").GetCustomerQuery>;
+    getTicket(variables: import("./sdks/drozchat").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").GetTicketQuery>;
+    listTickets(variables: import("./sdks/drozchat").Exact<{
+        state: import("./sdks/drozchat").TicketState;
+        assigneeId?: string;
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsQuery>;
+    listTicketsInQueue(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsInQueueQuery>;
+    listTicketsInProgressMine(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsInProgressMineQuery>;
+    listTicketsClosed(variables?: import("./sdks/drozchat").Exact<{
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketsClosedQuery>;
+    listTicketMessages(variables: import("./sdks/drozchat").Exact<{
+        ticketId: string;
+        next?: object;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").ListTicketMessagesQuery>;
+    createTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateTicketMutation>;
+    markTicketMessagesAsRead(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").MarkTicketMessagesAsReadInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").MarkTicketMessagesAsReadMutation>;
+    createTicketMessage(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CreateTicketMessageInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CreateTicketMessageMutation>;
+    assignTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").AssignTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").AssignTicketMutation>;
+    assignTicketMyself(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").AssignTicketMyselfInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").AssignTicketMyselfMutation>;
+    unassignTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").UnassignTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").UnassignTicketMutation>;
+    closeTicket(variables: import("./sdks/drozchat").Exact<{
+        input: import("./sdks/drozchat").CloseTicketInput;
+    }>, options?: unknown): Promise<import("./sdks/drozchat").CloseTicketMutation>;
+    onTicketInQueue(variables?: import("./sdks/drozchat").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketInQueueSubscription>;
+    onTicketInProgressMine(variables?: import("./sdks/drozchat").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketInProgressMineSubscription>;
+    onTicketClosed(variables?: import("./sdks/drozchat").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>;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketClosedSubscription>;
+    onTicketMessage(variables: import("./sdks/drozchat").Exact<{
+        ticketId: string;
+    }>, options?: unknown): AsyncIterable<import("./sdks/drozchat").OnTicketMessageSubscription>;
 };

package/src/drozchat.js

@@ -16,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DrozChat = void 0;
 const http_1 = require("./client/http");
-const drozbot_1 = require("./sdks/drozbot");
+const drozchat_1 = require("./sdks/drozchat");
 __exportStar(require("./sdks/drozchat"), exports);
-exports.DrozChat = (0, http_1.HttpClientBuilder)(drozbot_1.serviceName, drozbot_1.getSdk);
+exports.DrozChat = (0, http_1.HttpClientBuilder)(drozchat_1.serviceName, drozchat_1.getSdk);

package/src/mercadolivre.d.ts

@@ -0,0 +1,18 @@
+export * from './sdks/mercadolivre';
+export declare const MercadoLivre: new () => {
+    getMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
+        id: string;
+    }>, options?: unknown): Promise<import("./sdks/mercadolivre").GetMercadoLivreInstanceQuery>;
+    listMercadoLivreInstances(variables?: import("./sdks/mercadolivre").Exact<{
+        [key: string]: never;
+    }>, options?: unknown): Promise<import("./sdks/mercadolivre").ListMercadoLivreInstancesQuery>;
+    createMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
+        input: import("./sdks/mercadolivre").CreateMercadoLivreInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/mercadolivre").CreateMercadoLivreInstanceMutation>;
+    updateMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
+        input: import("./sdks/mercadolivre").UpdateMercadoLivreInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/mercadolivre").UpdateMercadoLivreInstanceMutation>;
+    removeMercadoLivreInstance(variables: import("./sdks/mercadolivre").Exact<{
+        input: import("./sdks/mercadolivre").RemoveMercadoLivreInstanceInput;
+    }>, options?: unknown): Promise<import("./sdks/mercadolivre").RemoveMercadoLivreInstanceMutation>;
+};

package/src/mercadolivre.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.MercadoLivre = void 0;
+const http_1 = require("./client/http");
+const mercadolivre_1 = require("./sdks/mercadolivre");
+__exportStar(require("./sdks/mercadolivre"), exports);
+exports.MercadoLivre = (0, http_1.HttpClientBuilder)(mercadolivre_1.serviceName, mercadolivre_1.getSdk);

package/src/sdks/drozbot.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -178,7 +177,7 @@ export declare const ListDrozBotInstancesDocument = "\n    query listDrozBotInst
 export declare const CreateDrozBotInstanceDocument = "\n    mutation createDrozBotInstance($input: CreateDrozBotInstanceInput!) {\n  createDrozBotInstance(input: $input) {\n    ...drozbot\n  }\n}\n    \n    fragment drozbot on DrozBotInstance {\n  id\n  name\n  credentialsId\n  isTest\n}\n    ";
 export declare const UpdateDrozBotInstanceDocument = "\n    mutation updateDrozBotInstance($input: UpdateDrozBotInstanceInput!) {\n  updateDrozBotInstance(input: $input) {\n    ...drozbot\n  }\n}\n    \n    fragment drozbot on DrozBotInstance {\n  id\n  name\n  credentialsId\n  isTest\n}\n    ";
 export declare const RemoveDrozBotInstanceDocument = "\n    mutation removeDrozBotInstance($input: RemoveDrozBotInstanceInput!) {\n  removeDrozBotInstance(input: $input) {\n    ...drozbot\n  }\n}\n    \n    fragment drozbot on DrozBotInstance {\n  id\n  name\n  credentialsId\n  isTest\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     getDrozBotInstance(variables: GetDrozBotInstanceQueryVariables, options?: C): Promise<GetDrozBotInstanceQuery>;
     listDrozBotInstances(variables?: ListDrozBotInstancesQueryVariables, options?: C): Promise<ListDrozBotInstancesQuery>;

package/src/sdks/drozchat.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -496,7 +495,7 @@ export declare const OnTicketInQueueDocument = "\n    subscription onTicketInQue
 export declare const OnTicketInProgressMineDocument = "\n    subscription onTicketInProgressMine {\n  onTicketInProgressMine {\n    ticket {\n      ...ticket\n    }\n    action\n  }\n}\n    \n    fragment ticket on Ticket {\n  id\n  state\n  status\n  priority\n  assignee {\n    ...agent\n  }\n  customer {\n    ...customer\n  }\n  messagesCount\n  lastMessage\n  lastMessageAt\n  unreadMessagesCount\n  createdAt\n  updatedAt\n}\n    \n\n    fragment agent on Agent {\n  id\n  name\n  email\n}\n    \n\n    fragment customer on Customer {\n  id\n  name\n  email\n  createdAt\n  updatedAt\n}\n    ";
 export declare const OnTicketClosedDocument = "\n    subscription onTicketClosed {\n  onTicketClosed {\n    ticket {\n      ...ticket\n    }\n    action\n  }\n}\n    \n    fragment ticket on Ticket {\n  id\n  state\n  status\n  priority\n  assignee {\n    ...agent\n  }\n  customer {\n    ...customer\n  }\n  messagesCount\n  lastMessage\n  lastMessageAt\n  unreadMessagesCount\n  createdAt\n  updatedAt\n}\n    \n\n    fragment agent on Agent {\n  id\n  name\n  email\n}\n    \n\n    fragment customer on Customer {\n  id\n  name\n  email\n  createdAt\n  updatedAt\n}\n    ";
 export declare const OnTicketMessageDocument = "\n    subscription onTicketMessage($ticketId: ID!) {\n  onTicketMessage(ticketId: $ticketId) {\n    message {\n      ...ticketMessage\n    }\n    action\n  }\n}\n    \n    fragment ticketMessage on TicketMessage {\n  id\n  ticketId\n  sentBy\n  type\n  contentType\n  body\n  createdAt\n  updatedAt\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     createCustomer(variables: CreateCustomerMutationVariables, options?: C): Promise<CreateCustomerMutation>;
     updateCustomer(variables: UpdateCustomerMutationVariables, options?: C): Promise<UpdateCustomerMutation>;
@@ -515,10 +514,10 @@ export declare function getSdk<C, E>(requester: Requester<C, E>): {
     assignTicketMyself(variables: AssignTicketMyselfMutationVariables, options?: C): Promise<AssignTicketMyselfMutation>;
     unassignTicket(variables: UnassignTicketMutationVariables, options?: C): Promise<UnassignTicketMutation>;
     closeTicket(variables: CloseTicketMutationVariables, options?: C): Promise<CloseTicketMutation>;
-    onTicketInQueue(variables?: OnTicketInQueueSubscriptionVariables, options?: C): Observable<OnTicketInQueueSubscription>;
-    onTicketInProgressMine(variables?: OnTicketInProgressMineSubscriptionVariables, options?: C): Observable<OnTicketInProgressMineSubscription>;
-    onTicketClosed(variables?: OnTicketClosedSubscriptionVariables, options?: C): Observable<OnTicketClosedSubscription>;
-    onTicketMessage(variables: OnTicketMessageSubscriptionVariables, options?: C): Observable<OnTicketMessageSubscription>;
+    onTicketInQueue(variables?: OnTicketInQueueSubscriptionVariables, options?: C): AsyncIterable<OnTicketInQueueSubscription>;
+    onTicketInProgressMine(variables?: OnTicketInProgressMineSubscriptionVariables, options?: C): AsyncIterable<OnTicketInProgressMineSubscription>;
+    onTicketClosed(variables?: OnTicketClosedSubscriptionVariables, options?: C): AsyncIterable<OnTicketClosedSubscription>;
+    onTicketMessage(variables: OnTicketMessageSubscriptionVariables, options?: C): AsyncIterable<OnTicketMessageSubscription>;
 };
 export type Sdk = ReturnType<typeof getSdk>;
 export declare const serviceName = "@droz/drozchat";

package/src/sdks/droznexo.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -206,7 +205,7 @@ export declare const ListAgentsDocument = "\n    query listAgents($next: Base64)
 export declare const GetAgentDocument = "\n    query getAgent($id: ID!) {\n  getAgent(id: $id) {\n    ...agent\n  }\n}\n    \n    fragment agent on Agent {\n  id\n  name\n  groupIds\n  createdAt\n  updatedAt\n  groups {\n    ...agentGroup\n  }\n}\n    \n\n    fragment agentGroup on AgentGroup {\n  id\n  name\n  createdAt\n  updatedAt\n}\n    ";
 export declare const CreateAgentGroupDocument = "\n    mutation createAgentGroup($input: CreateAgentGroupInput!) {\n  createAgentGroup(input: $input) {\n    ...agentGroup\n  }\n}\n    \n    fragment agentGroup on AgentGroup {\n  id\n  name\n  createdAt\n  updatedAt\n}\n    ";
 export declare const ListAgentGroupsDocument = "\n    query listAgentGroups($next: Base64) {\n  listAgentGroups(next: $next) {\n    pageInfo {\n      hasNext\n      next\n    }\n    nodes {\n      ...agentGroup\n    }\n  }\n}\n    \n    fragment agentGroup on AgentGroup {\n  id\n  name\n  createdAt\n  updatedAt\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     createAgent(variables: CreateAgentMutationVariables, options?: C): Promise<CreateAgentMutation>;
     listAgents(variables?: ListAgentsQueryVariables, options?: C): Promise<ListAgentsQuery>;

package/src/sdks/mercadolivre.d.ts

@@ -0,0 +1,193 @@
+export type Maybe<T> = T;
+export type InputMaybe<T> = 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;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Base64: {
+        input: object;
+        output: string;
+    };
+    DRN: {
+        input: string;
+        output: string;
+    };
+    Date: {
+        input: Date;
+        output: Date;
+    };
+    DateTime: {
+        input: Date;
+        output: Date;
+    };
+    EmailAddress: {
+        input: string;
+        output: string;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+    JSONObject: {
+        input: any;
+        output: any;
+    };
+    Set: {
+        input: any;
+        output: any;
+    };
+    URL: {
+        input: string;
+        output: string;
+    };
+    Void: {
+        input: void;
+        output: void;
+    };
+};
+export type CreateMercadoLivreInstanceInput = {
+    credentialId?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+    type: MercadoLivreInstanceType;
+};
+export type MercadoLivreInstance = {
+    credentialId?: Maybe<Scalars['ID']['output']>;
+    cronJobId?: Maybe<Scalars['ID']['output']>;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    type: MercadoLivreInstanceType;
+};
+export declare enum MercadoLivreInstanceType {
+    PosVenda = "POS_VENDA",
+    PreVenda = "PRE_VENDA",
+    Reclamacao = "RECLAMACAO"
+}
+export type Mutation = {
+    createMercadoLivreInstance?: Maybe<MercadoLivreInstance>;
+    removeMercadoLivreInstance?: Maybe<MercadoLivreInstance>;
+    updateMercadoLivreInstance?: Maybe<MercadoLivreInstance>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type MutationCreateMercadoLivreInstanceArgs = {
+    input: CreateMercadoLivreInstanceInput;
+};
+export type MutationRemoveMercadoLivreInstanceArgs = {
+    input: RemoveMercadoLivreInstanceInput;
+};
+export type MutationUpdateMercadoLivreInstanceArgs = {
+    input: UpdateMercadoLivreInstanceInput;
+};
+export type PageInfo = {
+    hasNext: Scalars['Boolean']['output'];
+    next?: Maybe<Scalars['Base64']['output']>;
+};
+export type Query = {
+    app?: Maybe<Scalars['DRN']['output']>;
+    getMercadoLivreInstance?: Maybe<MercadoLivreInstance>;
+    listMercadoLivreInstances: Array<MercadoLivreInstance>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type QueryGetMercadoLivreInstanceArgs = {
+    id: Scalars['ID']['input'];
+};
+export type RemoveMercadoLivreInstanceInput = {
+    id: Scalars['ID']['input'];
+};
+export type Subscription = {
+    version?: Maybe<Scalars['String']['output']>;
+};
+export declare enum Typenames {
+    Any = "Any",
+    GraphqlConnections = "GraphqlConnections",
+    GraphqlSubscriptions = "GraphqlSubscriptions",
+    MercadoLivreInstance = "MercadoLivreInstance"
+}
+export type UpdateMercadoLivreInstanceInput = {
+    credentialId?: InputMaybe<Scalars['ID']['input']>;
+    id: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type ReclameAquiInstanceFragment = Pick<MercadoLivreInstance, 'id' | 'name' | 'credentialId' | 'cronJobId'>;
+export type GetMercadoLivreInstanceQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type GetMercadoLivreInstanceQuery = {
+    getMercadoLivreInstance?: Maybe<ReclameAquiInstanceFragment>;
+};
+export type ListMercadoLivreInstancesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListMercadoLivreInstancesQuery = {
+    listMercadoLivreInstances: Array<ReclameAquiInstanceFragment>;
+};
+export type CreateMercadoLivreInstanceMutationVariables = Exact<{
+    input: CreateMercadoLivreInstanceInput;
+}>;
+export type CreateMercadoLivreInstanceMutation = {
+    createMercadoLivreInstance?: Maybe<ReclameAquiInstanceFragment>;
+};
+export type UpdateMercadoLivreInstanceMutationVariables = Exact<{
+    input: UpdateMercadoLivreInstanceInput;
+}>;
+export type UpdateMercadoLivreInstanceMutation = {
+    updateMercadoLivreInstance?: Maybe<ReclameAquiInstanceFragment>;
+};
+export type RemoveMercadoLivreInstanceMutationVariables = Exact<{
+    input: RemoveMercadoLivreInstanceInput;
+}>;
+export type RemoveMercadoLivreInstanceMutation = {
+    removeMercadoLivreInstance?: Maybe<ReclameAquiInstanceFragment>;
+};
+export declare const ReclameAquiInstanceFragmentDoc = "\n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export declare const GetMercadoLivreInstanceDocument = "\n    query getMercadoLivreInstance($id: ID!) {\n  getMercadoLivreInstance(id: $id) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export declare const ListMercadoLivreInstancesDocument = "\n    query listMercadoLivreInstances {\n  listMercadoLivreInstances {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export declare const CreateMercadoLivreInstanceDocument = "\n    mutation createMercadoLivreInstance($input: CreateMercadoLivreInstanceInput!) {\n  createMercadoLivreInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export declare const UpdateMercadoLivreInstanceDocument = "\n    mutation updateMercadoLivreInstance($input: UpdateMercadoLivreInstanceInput!) {\n  updateMercadoLivreInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export declare const RemoveMercadoLivreInstanceDocument = "\n    mutation removeMercadoLivreInstance($input: RemoveMercadoLivreInstanceInput!) {\n  removeMercadoLivreInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on MercadoLivreInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
+export declare function getSdk<C, E>(requester: Requester<C, E>): {
+    getMercadoLivreInstance(variables: GetMercadoLivreInstanceQueryVariables, options?: C): Promise<GetMercadoLivreInstanceQuery>;
+    listMercadoLivreInstances(variables?: ListMercadoLivreInstancesQueryVariables, options?: C): Promise<ListMercadoLivreInstancesQuery>;
+    createMercadoLivreInstance(variables: CreateMercadoLivreInstanceMutationVariables, options?: C): Promise<CreateMercadoLivreInstanceMutation>;
+    updateMercadoLivreInstance(variables: UpdateMercadoLivreInstanceMutationVariables, options?: C): Promise<UpdateMercadoLivreInstanceMutation>;
+    removeMercadoLivreInstance(variables: RemoveMercadoLivreInstanceMutationVariables, options?: C): Promise<RemoveMercadoLivreInstanceMutation>;
+};
+export type Sdk = ReturnType<typeof getSdk>;
+export declare const serviceName = "@droz/mercadolivre";

package/src/sdks/mercadolivre.js

@@ -0,0 +1,81 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceName = exports.getSdk = exports.RemoveMercadoLivreInstanceDocument = exports.UpdateMercadoLivreInstanceDocument = exports.CreateMercadoLivreInstanceDocument = exports.ListMercadoLivreInstancesDocument = exports.GetMercadoLivreInstanceDocument = exports.ReclameAquiInstanceFragmentDoc = exports.Typenames = exports.MercadoLivreInstanceType = void 0;
+var MercadoLivreInstanceType;
+(function (MercadoLivreInstanceType) {
+    MercadoLivreInstanceType["PosVenda"] = "POS_VENDA";
+    MercadoLivreInstanceType["PreVenda"] = "PRE_VENDA";
+    MercadoLivreInstanceType["Reclamacao"] = "RECLAMACAO";
+})(MercadoLivreInstanceType || (exports.MercadoLivreInstanceType = MercadoLivreInstanceType = {}));
+var Typenames;
+(function (Typenames) {
+    Typenames["Any"] = "Any";
+    Typenames["GraphqlConnections"] = "GraphqlConnections";
+    Typenames["GraphqlSubscriptions"] = "GraphqlSubscriptions";
+    Typenames["MercadoLivreInstance"] = "MercadoLivreInstance";
+})(Typenames || (exports.Typenames = Typenames = {}));
+exports.ReclameAquiInstanceFragmentDoc = `
+    fragment reclameAquiInstance on MercadoLivreInstance {
+  id
+  name
+  credentialId
+  cronJobId
+}
+    `;
+exports.GetMercadoLivreInstanceDocument = `
+    query getMercadoLivreInstance($id: ID!) {
+  getMercadoLivreInstance(id: $id) {
+    ...reclameAquiInstance
+  }
+}
+    ${exports.ReclameAquiInstanceFragmentDoc}`;
+exports.ListMercadoLivreInstancesDocument = `
+    query listMercadoLivreInstances {
+  listMercadoLivreInstances {
+    ...reclameAquiInstance
+  }
+}
+    ${exports.ReclameAquiInstanceFragmentDoc}`;
+exports.CreateMercadoLivreInstanceDocument = `
+    mutation createMercadoLivreInstance($input: CreateMercadoLivreInstanceInput!) {
+  createMercadoLivreInstance(input: $input) {
+    ...reclameAquiInstance
+  }
+}
+    ${exports.ReclameAquiInstanceFragmentDoc}`;
+exports.UpdateMercadoLivreInstanceDocument = `
+    mutation updateMercadoLivreInstance($input: UpdateMercadoLivreInstanceInput!) {
+  updateMercadoLivreInstance(input: $input) {
+    ...reclameAquiInstance
+  }
+}
+    ${exports.ReclameAquiInstanceFragmentDoc}`;
+exports.RemoveMercadoLivreInstanceDocument = `
+    mutation removeMercadoLivreInstance($input: RemoveMercadoLivreInstanceInput!) {
+  removeMercadoLivreInstance(input: $input) {
+    ...reclameAquiInstance
+  }
+}
+    ${exports.ReclameAquiInstanceFragmentDoc}`;
+function getSdk(requester) {
+    return {
+        getMercadoLivreInstance(variables, options) {
+            return requester(exports.GetMercadoLivreInstanceDocument, variables, options);
+        },
+        listMercadoLivreInstances(variables, options) {
+            return requester(exports.ListMercadoLivreInstancesDocument, variables, options);
+        },
+        createMercadoLivreInstance(variables, options) {
+            return requester(exports.CreateMercadoLivreInstanceDocument, variables, options);
+        },
+        updateMercadoLivreInstance(variables, options) {
+            return requester(exports.UpdateMercadoLivreInstanceDocument, variables, options);
+        },
+        removeMercadoLivreInstance(variables, options) {
+            return requester(exports.RemoveMercadoLivreInstanceDocument, variables, options);
+        }
+    };
+}
+exports.getSdk = getSdk;
+exports.serviceName = '@droz/mercadolivre';

package/src/sdks/nucleus.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -632,7 +631,7 @@ export declare const GetSessionDataDocument = "\n    query getSessionData($sessi
 export declare const SetSessionDataDocument = "\n    mutation setSessionData($input: SetSessionDataInput!) {\n  setSessionData(input: $input)\n}\n    ";
 export declare const PatchSessionDataDocument = "\n    mutation patchSessionData($input: PatchSessionDataInput!) {\n  patchSessionData(input: $input)\n}\n    ";
 export declare const GetStateMachineDocument = "\n    query getStateMachine($id: ID!, $versionId: ID!) {\n  getStateMachineConfig(id: $id, versionId: $versionId) {\n    id\n    versionId\n    stateMachineId\n    title\n    description\n    status\n    states {\n      stateId\n      on {\n        event\n        target\n      }\n      meta\n    }\n  }\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     getApp(variables: GetAppQueryVariables, options?: C): Promise<GetAppQuery>;
     listApps(variables?: ListAppsQueryVariables, options?: C): Promise<ListAppsQuery>;

package/src/sdks/reclameaqui.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -176,7 +175,7 @@ export declare const ListReclameAquiInstancesDocument = "\n    query listReclame
 export declare const CreateReclameAquiInstanceDocument = "\n    mutation createReclameAquiInstance($input: CreateReclameAquiInstanceInput!) {\n  createReclameAquiInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on ReclameAquiInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
 export declare const UpdateReclameAquiInstanceDocument = "\n    mutation updateReclameAquiInstance($input: UpdateReclameAquiInstanceInput!) {\n  updateReclameAquiInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on ReclameAquiInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
 export declare const RemoveReclameAquiInstanceDocument = "\n    mutation removeReclameAquiInstance($input: RemoveReclameAquiInstanceInput!) {\n  removeReclameAquiInstance(input: $input) {\n    ...reclameAquiInstance\n  }\n}\n    \n    fragment reclameAquiInstance on ReclameAquiInstance {\n  id\n  name\n  credentialId\n  cronJobId\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     getReclameAquiInstance(variables: GetReclameAquiInstanceQueryVariables, options?: C): Promise<GetReclameAquiInstanceQuery>;
     listReclameAquiInstances(variables?: ListReclameAquiInstancesQueryVariables, options?: C): Promise<ListReclameAquiInstancesQuery>;

package/src/sdks/zendesk.d.ts

@@ -1,4 +1,3 @@
-import Observable from 'zen-observable';
 export type Maybe<T> = T;
 export type InputMaybe<T> = T;
 export type Exact<T extends {
@@ -193,7 +192,7 @@ export declare const ListZendeskInstancesDocument = "\n    query listZendeskInst
 export declare const CreateZendeskInstanceDocument = "\n    mutation createZendeskInstance($input: CreateZendeskInstanceInput!) {\n  createZendeskInstance(input: $input) {\n    ...zendeskInstance\n  }\n}\n    \n    fragment zendeskInstance on ZendeskInstance {\n  id\n  name\n  domain\n  credentialId\n}\n    ";
 export declare const UpdateZendeskInstanceDocument = "\n    mutation updateZendeskInstance($input: UpdateZendeskInstanceInput!) {\n  updateZendeskInstance(input: $input) {\n    ...zendeskInstance\n  }\n}\n    \n    fragment zendeskInstance on ZendeskInstance {\n  id\n  name\n  domain\n  credentialId\n}\n    ";
 export declare const RemoveZendeskInstanceDocument = "\n    mutation removeZendeskInstance($input: RemoveZendeskInstanceInput!) {\n  removeZendeskInstance(input: $input) {\n    ...zendeskInstance\n  }\n}\n    \n    fragment zendeskInstance on ZendeskInstance {\n  id\n  name\n  domain\n  credentialId\n}\n    ";
-export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | Observable<R>;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
 export declare function getSdk<C, E>(requester: Requester<C, E>): {
     getZendeskInstance(variables: GetZendeskInstanceQueryVariables, options?: C): Promise<GetZendeskInstanceQuery>;
     listZendeskInstances(variables?: ListZendeskInstancesQueryVariables, options?: C): Promise<ListZendeskInstancesQuery>;