@gtmi/ramp-dialog-client 0.0.1

package/dist/es/index.mjs

@@ -0,0 +1,1042 @@
+import { z } from 'zod';
+
+// This file is auto-generated by @hey-api/openapi-ts
+const jsonBodySerializer = {
+    bodySerializer: (body)=>JSON.stringify(body, (_key, value)=>typeof value === 'bigint' ? value.toString() : value)
+};
+
+// This file is auto-generated by @hey-api/openapi-ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+    let lastEventId;
+    const sleep = sseSleepFn ?? ((ms)=>new Promise((resolve)=>setTimeout(resolve, ms)));
+    const createStream = async function*() {
+        let retryDelay = sseDefaultRetryDelay ?? 3000;
+        let attempt = 0;
+        const signal = options.signal ?? new AbortController().signal;
+        while(true){
+            if (signal.aborted) break;
+            attempt++;
+            const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+            if (lastEventId !== undefined) {
+                headers.set('Last-Event-ID', lastEventId);
+            }
+            try {
+                const requestInit = {
+                    redirect: 'follow',
+                    ...options,
+                    body: options.serializedBody,
+                    headers,
+                    signal
+                };
+                let request = new Request(url, requestInit);
+                if (onRequest) {
+                    request = await onRequest(url, requestInit);
+                }
+                // fetch must be assigned here, otherwise it would throw the error:
+                // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+                const _fetch = options.fetch ?? globalThis.fetch;
+                const response = await _fetch(request);
+                if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+                if (!response.body) throw new Error('No body in SSE response');
+                const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+                let buffer = '';
+                const abortHandler = ()=>{
+                    try {
+                        reader.cancel();
+                    } catch  {
+                    // noop
+                    }
+                };
+                signal.addEventListener('abort', abortHandler);
+                try {
+                    while(true){
+                        const { done, value } = await reader.read();
+                        if (done) break;
+                        buffer += value;
+                        buffer = buffer.replace(/\r\n?/g, '\n'); // normalize line endings
+                        const chunks = buffer.split('\n\n');
+                        buffer = chunks.pop() ?? '';
+                        for (const chunk of chunks){
+                            const lines = chunk.split('\n');
+                            const dataLines = [];
+                            let eventName;
+                            for (const line of lines){
+                                if (line.startsWith('data:')) {
+                                    dataLines.push(line.replace(/^data:\s*/, ''));
+                                } else if (line.startsWith('event:')) {
+                                    eventName = line.replace(/^event:\s*/, '');
+                                } else if (line.startsWith('id:')) {
+                                    lastEventId = line.replace(/^id:\s*/, '');
+                                } else if (line.startsWith('retry:')) {
+                                    const parsed = Number.parseInt(line.replace(/^retry:\s*/, ''), 10);
+                                    if (!Number.isNaN(parsed)) {
+                                        retryDelay = parsed;
+                                    }
+                                }
+                            }
+                            let data;
+                            let parsedJson = false;
+                            if (dataLines.length) {
+                                const rawData = dataLines.join('\n');
+                                try {
+                                    data = JSON.parse(rawData);
+                                    parsedJson = true;
+                                } catch  {
+                                    data = rawData;
+                                }
+                            }
+                            if (parsedJson) {
+                                if (responseValidator) {
+                                    await responseValidator(data);
+                                }
+                                if (responseTransformer) {
+                                    data = await responseTransformer(data);
+                                }
+                            }
+                            onSseEvent?.({
+                                data,
+                                event: eventName,
+                                id: lastEventId,
+                                retry: retryDelay
+                            });
+                            if (dataLines.length) {
+                                yield data;
+                            }
+                        }
+                    }
+                } finally{
+                    signal.removeEventListener('abort', abortHandler);
+                    reader.releaseLock();
+                }
+                break; // exit loop on normal completion
+            } catch (error) {
+                // connection failed or aborted; retry after delay
+                onSseError?.(error);
+                if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+                    break; // stop after firing error
+                }
+                // exponential backoff: double retry each attempt, cap at 30s
+                const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+                await sleep(backoff);
+            }
+        }
+    };
+    const stream = createStream();
+    return {
+        stream
+    };
+}
+
+// This file is auto-generated by @hey-api/openapi-ts
+const separatorArrayExplode = (style)=>{
+    switch(style){
+        case 'label':
+            return '.';
+        case 'matrix':
+            return ';';
+        case 'simple':
+            return ',';
+        default:
+            return '&';
+    }
+};
+const separatorArrayNoExplode = (style)=>{
+    switch(style){
+        case 'form':
+            return ',';
+        case 'pipeDelimited':
+            return '|';
+        case 'spaceDelimited':
+            return '%20';
+        default:
+            return ',';
+    }
+};
+const separatorObjectExplode = (style)=>{
+    switch(style){
+        case 'label':
+            return '.';
+        case 'matrix':
+            return ';';
+        case 'simple':
+            return ',';
+        default:
+            return '&';
+    }
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value })=>{
+    if (!explode) {
+        const joinedValues = (allowReserved ? value : value.map((v)=>encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+        switch(style){
+            case 'label':
+                return `.${joinedValues}`;
+            case 'matrix':
+                return `;${name}=${joinedValues}`;
+            case 'simple':
+                return joinedValues;
+            default:
+                return `${name}=${joinedValues}`;
+        }
+    }
+    const separator = separatorArrayExplode(style);
+    const joinedValues = value.map((v)=>{
+        if (style === 'label' || style === 'simple') {
+            return allowReserved ? v : encodeURIComponent(v);
+        }
+        return serializePrimitiveParam({
+            allowReserved,
+            name,
+            value: v
+        });
+    }).join(separator);
+    return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value })=>{
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        throw new Error('Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.');
+    }
+    return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly })=>{
+    if (value instanceof Date) {
+        return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+    }
+    if (style !== 'deepObject' && !explode) {
+        let values = [];
+        Object.entries(value).forEach(([key, v])=>{
+            values = [
+                ...values,
+                key,
+                allowReserved ? v : encodeURIComponent(v)
+            ];
+        });
+        const joinedValues = values.join(',');
+        switch(style){
+            case 'form':
+                return `${name}=${joinedValues}`;
+            case 'label':
+                return `.${joinedValues}`;
+            case 'matrix':
+                return `;${name}=${joinedValues}`;
+            default:
+                return joinedValues;
+        }
+    }
+    const separator = separatorObjectExplode(style);
+    const joinedValues = Object.entries(value).map(([key, v])=>serializePrimitiveParam({
+            allowReserved,
+            name: style === 'deepObject' ? `${name}[${key}]` : key,
+            value: v
+        })).join(separator);
+    return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues;
+};
+
+// This file is auto-generated by @hey-api/openapi-ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url })=>{
+    let url = _url;
+    const matches = _url.match(PATH_PARAM_RE);
+    if (matches) {
+        for (const match of matches){
+            let explode = false;
+            let name = match.substring(1, match.length - 1);
+            let style = 'simple';
+            if (name.endsWith('*')) {
+                explode = true;
+                name = name.substring(0, name.length - 1);
+            }
+            if (name.startsWith('.')) {
+                name = name.substring(1);
+                style = 'label';
+            } else if (name.startsWith(';')) {
+                name = name.substring(1);
+                style = 'matrix';
+            }
+            const value = path[name];
+            if (value === undefined || value === null) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                url = url.replace(match, serializeArrayParam({
+                    explode,
+                    name,
+                    style,
+                    value
+                }));
+                continue;
+            }
+            if (typeof value === 'object') {
+                url = url.replace(match, serializeObjectParam({
+                    explode,
+                    name,
+                    style,
+                    value: value,
+                    valueOnly: true
+                }));
+                continue;
+            }
+            if (style === 'matrix') {
+                url = url.replace(match, `;${serializePrimitiveParam({
+                    name,
+                    value: value
+                })}`);
+                continue;
+            }
+            const replaceValue = encodeURIComponent(style === 'label' ? `.${value}` : value);
+            url = url.replace(match, replaceValue);
+        }
+    }
+    return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url })=>{
+    const pathUrl = _url.startsWith('/') ? _url : `/${_url}`;
+    let url = (baseUrl ?? '') + pathUrl;
+    if (path) {
+        url = defaultPathSerializer({
+            path,
+            url
+        });
+    }
+    let search = query ? querySerializer(query) : '';
+    if (search.startsWith('?')) {
+        search = search.substring(1);
+    }
+    if (search) {
+        url += `?${search}`;
+    }
+    return url;
+};
+function getValidRequestBody(options) {
+    const hasBody = options.body !== undefined;
+    const isSerializedBody = hasBody && options.bodySerializer;
+    if (isSerializedBody) {
+        if ('serializedBody' in options) {
+            const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== '';
+            return hasSerializedBody ? options.serializedBody : null;
+        }
+        // not all clients implement a serializedBody property (i.e., client-axios)
+        return options.body !== '' ? options.body : null;
+    }
+    // plain/text body
+    if (hasBody) {
+        return options.body;
+    }
+    // no body was provided
+    return undefined;
+}
+
+// This file is auto-generated by @hey-api/openapi-ts
+const getAuthToken = async (auth, callback)=>{
+    const token = typeof callback === 'function' ? await callback(auth) : callback;
+    if (!token) {
+        return;
+    }
+    if (auth.scheme === 'bearer') {
+        return `Bearer ${token}`;
+    }
+    if (auth.scheme === 'basic') {
+        return `Basic ${btoa(token)}`;
+    }
+    return token;
+};
+
+// This file is auto-generated by @hey-api/openapi-ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {})=>{
+    const querySerializer = (queryParams)=>{
+        const search = [];
+        if (queryParams && typeof queryParams === 'object') {
+            for(const name in queryParams){
+                const value = queryParams[name];
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                const options = parameters[name] || args;
+                if (Array.isArray(value)) {
+                    const serializedArray = serializeArrayParam({
+                        allowReserved: options.allowReserved,
+                        explode: true,
+                        name,
+                        style: 'form',
+                        value,
+                        ...options.array
+                    });
+                    if (serializedArray) search.push(serializedArray);
+                } else if (typeof value === 'object') {
+                    const serializedObject = serializeObjectParam({
+                        allowReserved: options.allowReserved,
+                        explode: true,
+                        name,
+                        style: 'deepObject',
+                        value: value,
+                        ...options.object
+                    });
+                    if (serializedObject) search.push(serializedObject);
+                } else {
+                    const serializedPrimitive = serializePrimitiveParam({
+                        allowReserved: options.allowReserved,
+                        name,
+                        value: value
+                    });
+                    if (serializedPrimitive) search.push(serializedPrimitive);
+                }
+            }
+        }
+        return search.join('&');
+    };
+    return querySerializer;
+};
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */ const getParseAs = (contentType)=>{
+    if (!contentType) {
+        // If no Content-Type header is provided, the best we can do is return the raw response body,
+        // which is effectively the same as the 'stream' option.
+        return 'stream';
+    }
+    const cleanContent = contentType.split(';')[0]?.trim();
+    if (!cleanContent) {
+        return;
+    }
+    if (cleanContent.startsWith('application/json') || cleanContent.endsWith('+json')) {
+        return 'json';
+    }
+    if (cleanContent === 'multipart/form-data') {
+        return 'formData';
+    }
+    if ([
+        'application/',
+        'audio/',
+        'image/',
+        'video/'
+    ].some((type)=>cleanContent.startsWith(type))) {
+        return 'blob';
+    }
+    if (cleanContent.startsWith('text/')) {
+        return 'text';
+    }
+    return;
+};
+const checkForExistence = (options, name)=>{
+    if (!name) {
+        return false;
+    }
+    if (options.headers.has(name) || options.query?.[name] || options.headers.get('Cookie')?.includes(`${name}=`)) {
+        return true;
+    }
+    return false;
+};
+async function setAuthParams(options) {
+    for (const auth of options.security ?? []){
+        if (checkForExistence(options, auth.name)) {
+            continue;
+        }
+        const token = await getAuthToken(auth, options.auth);
+        if (!token) {
+            continue;
+        }
+        const name = auth.name ?? 'Authorization';
+        switch(auth.in){
+            case 'query':
+                if (!options.query) {
+                    options.query = {};
+                }
+                options.query[name] = token;
+                break;
+            case 'cookie':
+                options.headers.append('Cookie', `${name}=${token}`);
+                break;
+            case 'header':
+            default:
+                options.headers.set(name, token);
+                break;
+        }
+    }
+}
+const buildUrl = (options)=>getUrl({
+        baseUrl: options.baseUrl,
+        path: options.path,
+        query: options.query,
+        querySerializer: typeof options.querySerializer === 'function' ? options.querySerializer : createQuerySerializer(options.querySerializer),
+        url: options.url
+    });
+const mergeConfigs = (a, b)=>{
+    const config = {
+        ...a,
+        ...b
+    };
+    if (config.baseUrl?.endsWith('/')) {
+        config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+    }
+    config.headers = mergeHeaders(a.headers, b.headers);
+    return config;
+};
+const headersEntries = (headers)=>{
+    const entries = [];
+    headers.forEach((value, key)=>{
+        entries.push([
+            key,
+            value
+        ]);
+    });
+    return entries;
+};
+const mergeHeaders = (...headers)=>{
+    const mergedHeaders = new Headers();
+    for (const header of headers){
+        if (!header) {
+            continue;
+        }
+        const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+        for (const [key, value] of iterator){
+            if (value === null) {
+                mergedHeaders.delete(key);
+            } else if (Array.isArray(value)) {
+                for (const v of value){
+                    mergedHeaders.append(key, v);
+                }
+            } else if (value !== undefined) {
+                // assume object headers are meant to be JSON stringified, i.e., their
+                // content value in OpenAPI specification is 'application/json'
+                mergedHeaders.set(key, typeof value === 'object' ? JSON.stringify(value) : value);
+            }
+        }
+    }
+    return mergedHeaders;
+};
+class Interceptors {
+    clear() {
+        this.fns = [];
+    }
+    eject(id) {
+        const index = this.getInterceptorIndex(id);
+        if (this.fns[index]) {
+            this.fns[index] = null;
+        }
+    }
+    exists(id) {
+        const index = this.getInterceptorIndex(id);
+        return Boolean(this.fns[index]);
+    }
+    getInterceptorIndex(id) {
+        if (typeof id === 'number') {
+            return this.fns[id] ? id : -1;
+        }
+        return this.fns.indexOf(id);
+    }
+    update(id, fn) {
+        const index = this.getInterceptorIndex(id);
+        if (this.fns[index]) {
+            this.fns[index] = fn;
+            return id;
+        }
+        return false;
+    }
+    use(fn) {
+        this.fns.push(fn);
+        return this.fns.length - 1;
+    }
+    constructor(){
+        this.fns = [];
+    }
+}
+const createInterceptors = ()=>({
+        error: new Interceptors(),
+        request: new Interceptors(),
+        response: new Interceptors()
+    });
+const defaultQuerySerializer = createQuerySerializer({
+    allowReserved: false,
+    array: {
+        explode: true,
+        style: 'form'
+    },
+    object: {
+        explode: true,
+        style: 'deepObject'
+    }
+});
+const defaultHeaders = {
+    'Content-Type': 'application/json'
+};
+const createConfig = (override = {})=>({
+        ...jsonBodySerializer,
+        headers: defaultHeaders,
+        parseAs: 'auto',
+        querySerializer: defaultQuerySerializer,
+        ...override
+    });
+
+// This file is auto-generated by @hey-api/openapi-ts
+const createClient = (config = {})=>{
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = ()=>({
+            ..._config
+        });
+    const setConfig = (config)=>{
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options)=>{
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined
+        };
+        if (opts.security) {
+            await setAuthParams(opts);
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const resolvedOpts = opts;
+        const url = buildUrl(resolvedOpts);
+        return {
+            opts: resolvedOpts,
+            url
+        };
+    };
+    const request = async (options)=>{
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
+        let response;
+        try {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts)
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns){
+                if (fn) {
+                    request = await fn(request, opts);
+                }
+            }
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns){
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
+            }
+            const result = {
+                request,
+                response
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto' ? getParseAs(response.headers.get('Content-Type')) : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch(parseAs){
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data' ? emptyData : {
+                        data: emptyData,
+                        ...result
+                    };
+                }
+                let data;
+                switch(parseAs){
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'formData':
+                    case 'text':
+                        data = await response[parseAs]();
+                        break;
+                    case 'json':
+                        {
+                            // Some servers return 200 with no Content-Length and empty body.
+                            // response.json() would throw; read as text and parse if non-empty.
+                            const text = await response.text();
+                            data = text ? JSON.parse(text) : {};
+                            break;
+                        }
+                    case 'stream':
+                        return opts.responseStyle === 'data' ? response.body : {
+                            data: response.body,
+                            ...result
+                        };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
+                }
+                return opts.responseStyle === 'data' ? data : {
+                    data,
+                    ...result
+                };
+            }
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
+            } catch  {
+            // noop
+            }
+            throw jsonError ?? textError;
+        } catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns){
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
+                }
+            }
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data' ? undefined : {
+                error: finalError,
+                request,
+                response
+            };
+        }
+    };
+    const makeMethodFn = (method)=>(options)=>request({
+                ...options,
+                method
+            });
+    const makeSseFn = (method)=>async (options)=>{
+            const { opts, url } = await beforeRequest(options);
+            return createSseClient({
+                ...opts,
+                body: opts.body,
+                method,
+                onRequest: async (url, init)=>{
+                    let request = new Request(url, init);
+                    for (const fn of interceptors.request.fns){
+                        if (fn) {
+                            request = await fn(request, opts);
+                        }
+                    }
+                    return request;
+                },
+                serializedBody: getValidRequestBody(opts),
+                url
+            });
+        };
+    const _buildUrl = (options)=>buildUrl({
+            ..._config,
+            ...options
+        });
+    return {
+        buildUrl: _buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE')
+        },
+        trace: makeMethodFn('TRACE')
+    };
+};
+
+const createRampDialogClient = ({ baseUrl, getAuthToken, ...config })=>createClient(createConfig({
+        baseUrl,
+        ...getAuthToken ? {
+            auth: getAuthToken
+        } : {},
+        ...config
+    }));
+
+// This file is auto-generated by @hey-api/openapi-ts
+const client = createClient(createConfig());
+
+// This file is auto-generated by @hey-api/openapi-ts
+/**
+ * GET active-conversations / {customerNumber}
+ */ const getApiActiveConversationsByCustomerNumber = (options)=>(options.client ?? client).get({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/active-conversations/{customerNumber}',
+        ...options
+    });
+/**
+ * GET active-conversations / agent / {agentNumber}
+ */ const getApiActiveConversationsAgentByAgentNumber = (options)=>(options.client ?? client).get({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/active-conversations/agent/{agentNumber}',
+        ...options
+    });
+/**
+ * POST active-conversations / agent / claim
+ */ const postApiActiveConversationsAgentClaim = (options)=>(options.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/active-conversations/agent/claim',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        }
+    });
+/**
+ * POST clear
+ */ const postApiClear = (options)=>(options.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/clear',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        }
+    });
+/**
+ * POST conversation-memory / profiles-lookup
+ */ const postApiConversationMemoryProfilesLookup = (options)=>(options.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/conversation-memory/profiles-lookup',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        }
+    });
+/**
+ * POST conversation-memory / recall
+ */ const postApiConversationMemoryRecall = (options)=>(options.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/conversation-memory/recall',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        }
+    });
+/**
+ * DELETE conversation-memory / reset
+ */ const deleteApiConversationMemoryReset = (options)=>(options.client ?? client).delete({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/conversation-memory/reset',
+        ...options
+    });
+/**
+ * GET country-configs
+ */ const getApiCountryConfigs = (options)=>(options?.client ?? client).get({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/country-configs',
+        ...options
+    });
+/**
+ * DELETE kill-conversation / {phone}
+ */ const deleteApiKillConversationByPhone = (options)=>(options.client ?? client).delete({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/kill-conversation/{phone}',
+        ...options
+    });
+/**
+ * DELETE live-numbers
+ */ const deleteApiLiveNumbers = (options)=>(options?.client ?? client).delete({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/live-numbers',
+        ...options
+    });
+/**
+ * GET messages
+ */ const getApiMessages = (options)=>(options?.client ?? client).get({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/messages',
+        ...options
+    });
+/**
+ * POST real-time-cintel-ui
+ */ const postApiRealTimeCintelUi = (options)=>(options.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/real-time-cintel-ui',
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        }
+    });
+/**
+ * GET sync-token
+ */ const getApiSyncToken = (options)=>(options?.client ?? client).get({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/sync-token',
+        ...options
+    });
+/**
+ * POST telemetry
+ */ const postApiTelemetry = (options)=>(options?.client ?? client).post({
+        security: [
+            {
+                in: 'cookie',
+                name: 'next-auth.session-token',
+                type: 'apiKey'
+            }
+        ],
+        url: '/api/telemetry',
+        ...options
+    });
+
+// This file is auto-generated by @hey-api/openapi-ts
+const zGetApiActiveConversationsByCustomerNumberPath = z.object({
+    customerNumber: z.string()
+});
+const zGetApiActiveConversationsAgentByAgentNumberPath = z.object({
+    agentNumber: z.string()
+});
+const zPostApiActiveConversationsAgentClaimBody = z.record(z.unknown());
+const zPostApiClearBody = z.record(z.unknown());
+const zPostApiConversationMemoryProfilesLookupBody = z.record(z.unknown());
+const zPostApiConversationMemoryRecallBody = z.record(z.unknown());
+const zDeleteApiConversationMemoryResetQuery = z.object({
+    profileId: z.string()
+});
+const zDeleteApiKillConversationByPhonePath = z.object({
+    phone: z.string()
+});
+const zGetApiMessagesQuery = z.object({
+    lastId: z.string().optional(),
+    phoneNumber: z.string().optional()
+});
+const zPostApiRealTimeCintelUiBody = z.record(z.unknown());
+const zPostApiTelemetryQuery = z.object({
+    ddforward: z.string().optional()
+});
+
+var zod_gen = {
+  __proto__: null,
+  zDeleteApiConversationMemoryResetQuery: zDeleteApiConversationMemoryResetQuery,
+  zDeleteApiKillConversationByPhonePath: zDeleteApiKillConversationByPhonePath,
+  zGetApiActiveConversationsAgentByAgentNumberPath: zGetApiActiveConversationsAgentByAgentNumberPath,
+  zGetApiActiveConversationsByCustomerNumberPath: zGetApiActiveConversationsByCustomerNumberPath,
+  zGetApiMessagesQuery: zGetApiMessagesQuery,
+  zPostApiActiveConversationsAgentClaimBody: zPostApiActiveConversationsAgentClaimBody,
+  zPostApiClearBody: zPostApiClearBody,
+  zPostApiConversationMemoryProfilesLookupBody: zPostApiConversationMemoryProfilesLookupBody,
+  zPostApiConversationMemoryRecallBody: zPostApiConversationMemoryRecallBody,
+  zPostApiRealTimeCintelUiBody: zPostApiRealTimeCintelUiBody,
+  zPostApiTelemetryQuery: zPostApiTelemetryQuery
+};
+
+export { createRampDialogClient, deleteApiConversationMemoryReset, deleteApiKillConversationByPhone, deleteApiLiveNumbers, getApiActiveConversationsAgentByAgentNumber, getApiActiveConversationsByCustomerNumber, getApiCountryConfigs, getApiMessages, getApiSyncToken, postApiActiveConversationsAgentClaim, postApiClear, postApiConversationMemoryProfilesLookup, postApiConversationMemoryRecall, postApiRealTimeCintelUi, postApiTelemetry, zod_gen as schemas };