@webzaytsev/support-sdk 0.1.0 → 0.1.1

package/dist/types.gen-DHi9F3K-.d.ts

@@ -0,0 +1,670 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions$1 {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+type ClientOptions = {
+    baseUrl: string;
+};
+type WebProfileDto = {
+    /**
+     * Display name (≤120 chars)
+     */
+    name: string;
+    /**
+     * User email
+     */
+    email?: string;
+    /**
+     * URL to user profile in admin panel
+     */
+    profileUrl?: string;
+    /**
+     * Key-value pairs (≤32 keys, key ≤64, value ≤512). Read by plugins (e.g. Remnawave reads userId).
+     */
+    extra?: {
+        [key: string]: string;
+    };
+};
+type IssueTokenDto = {
+    /**
+     * External user ID from your backend database
+     */
+    userId: string;
+    /**
+     * User profile snapshot passed from your backend
+     */
+    userProfile: WebProfileDto;
+    /**
+     * JWT TTL in seconds (max 3600, default 900)
+     */
+    ttlSec?: number;
+};
+type IssueTokenResponseDto = {
+    /**
+     * Short-lived JWT for widget authentication
+     */
+    token: string;
+    /**
+     * ISO timestamp when the token expires
+     */
+    expiresAt: string;
+};
+type WebSseEventDataDto = {
+    /**
+     * Message ID (for 'message' events)
+     */
+    messageId?: number;
+    /**
+     * Message text
+     */
+    text?: string;
+    /**
+     * Attachment upload IDs
+     */
+    attachmentIds?: Array<string>;
+    /**
+     * Message ID that triggered escalation ('escalation_ack' event)
+     */
+    escalatableMessageId?: number;
+    /**
+     * Escalation source
+     */
+    source?: string;
+    /**
+     * ISO timestamp of the event
+     */
+    createdAt?: string;
+    /**
+     * Human-readable message for system events
+     */
+    message?: string;
+};
+type WebSseEventDto = {
+    /**
+     * Event type
+     */
+    type: 'message' | 'resolved' | 'closed' | 'escalation_ack' | 'reopened' | 'heartbeat';
+    /**
+     * Ticket ID this event belongs to
+     */
+    ticketId: number;
+    /**
+     * Event payload (absent for heartbeat)
+     */
+    data?: WebSseEventDataDto;
+};
+type SendMessageDto = {
+    /**
+     * Message text
+     */
+    text: string;
+    /**
+     * Upload IDs returned by POST /web/uploads
+     */
+    attachmentIds?: Array<string>;
+};
+type SendMessageResponseDto = {
+    /**
+     * Ticket ID (created or existing)
+     */
+    ticketId: number;
+    /**
+     * ID of the recorded message
+     */
+    messageId: number;
+    /**
+     * ISO timestamp when the message was created
+     */
+    createdAt: string;
+};
+type TicketInfoDto = {
+    /**
+     * Ticket ID
+     */
+    id: number;
+    /**
+     * Ticket status
+     */
+    status: 'open' | 'closed';
+    /**
+     * ISO timestamp when ticket was created
+     */
+    createdAt: string;
+    /**
+     * ISO timestamp of last update
+     */
+    updatedAt: string;
+};
+type MessageDto = {
+    /**
+     * Message ID
+     */
+    id: number;
+    /**
+     * Message author role
+     */
+    role: 'user' | 'moderator' | 'bot' | 'system';
+    /**
+     * Text content of the message
+     */
+    content: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Upload IDs of attached images
+     */
+    webAttachmentIds: Array<string> | null;
+    /**
+     * ISO timestamp when the message was created
+     */
+    createdAt: string;
+};
+type CurrentTicketResponseDto = {
+    /**
+     * Current open ticket, null if none
+     */
+    ticket: TicketInfoDto | null;
+    /**
+     * Messages in chronological order (oldest first, max 50)
+     */
+    messages: Array<MessageDto>;
+};
+type MessagesResponseDto = {
+    /**
+     * Messages in chronological order (oldest first)
+     */
+    messages: Array<MessageDto>;
+    /**
+     * Pass as ?since= in the next poll request. Null when no messages returned.
+     */
+    nextCursor: {
+        [key: string]: unknown;
+    } | null;
+};
+type UploadResponseDto = {
+    /**
+     * Upload ID to use in attachmentIds when sending a message
+     */
+    uploadId: string;
+    /**
+     * MIME type of the uploaded file
+     */
+    mimeType: string;
+    /**
+     * File size in bytes
+     */
+    sizeBytes: number;
+};
+type WebAuthControllerIssueTokenData = {
+    body: IssueTokenDto;
+    path?: never;
+    query?: never;
+    url: '/web/auth/token';
+};
+type WebAuthControllerIssueTokenResponses = {
+    /**
+     * Short-lived JWT issued
+     */
+    200: IssueTokenResponseDto;
+};
+type WebAuthControllerIssueTokenResponse = WebAuthControllerIssueTokenResponses[keyof WebAuthControllerIssueTokenResponses];
+type WebTicketsControllerSendMessageData = {
+    body: SendMessageDto;
+    path?: never;
+    query?: never;
+    url: '/web/messages';
+};
+type WebTicketsControllerSendMessageResponses = {
+    /**
+     * Message recorded
+     */
+    200: SendMessageResponseDto;
+};
+type WebTicketsControllerSendMessageResponse = WebTicketsControllerSendMessageResponses[keyof WebTicketsControllerSendMessageResponses];
+type WebTicketsControllerGetCurrentTicketData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/web/tickets/current';
+};
+type WebTicketsControllerGetCurrentTicketResponses = {
+    /**
+     * Current ticket state
+     */
+    200: CurrentTicketResponseDto;
+};
+type WebTicketsControllerGetCurrentTicketResponse = WebTicketsControllerGetCurrentTicketResponses[keyof WebTicketsControllerGetCurrentTicketResponses];
+type WebTicketsControllerGetMessagesData = {
+    body?: never;
+    path: {
+        /**
+         * Ticket ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * ISO timestamp cursor from previous response nextCursor
+         */
+        since?: string;
+        /**
+         * Max messages to return (1–100, default 50)
+         */
+        limit?: string;
+    };
+    url: '/web/tickets/{id}/messages';
+};
+type WebTicketsControllerGetMessagesResponses = {
+    /**
+     * Messages since cursor
+     */
+    200: MessagesResponseDto;
+};
+type WebTicketsControllerGetMessagesResponse = WebTicketsControllerGetMessagesResponses[keyof WebTicketsControllerGetMessagesResponses];
+type WebTicketsControllerSseStreamData = {
+    body?: never;
+    path: {
+        /**
+         * Ticket ID
+         */
+        id: number;
+    };
+    query?: {
+        /**
+         * JWT token (alternative to Authorization header, required for native EventSource)
+         */
+        access_token?: unknown;
+    };
+    url: '/web/tickets/{id}/stream';
+};
+type WebTicketsControllerSseStreamResponses = {
+    /**
+     * Server-Sent Events stream
+     */
+    200: WebSseEventDto;
+};
+type WebTicketsControllerSseStreamResponse = WebTicketsControllerSseStreamResponses[keyof WebTicketsControllerSseStreamResponses];
+type WebTicketsControllerEscalateData = {
+    body?: never;
+    path: {
+        /**
+         * Ticket ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/web/tickets/{id}/escalate';
+};
+type WebTicketsControllerEscalateResponses = {
+    /**
+     * Escalation request submitted
+     */
+    204: void;
+};
+type WebTicketsControllerEscalateResponse = WebTicketsControllerEscalateResponses[keyof WebTicketsControllerEscalateResponses];
+type WebTicketsControllerResolveByUserData = {
+    body?: never;
+    path: {
+        /**
+         * Ticket ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: '/web/tickets/{id}/resolve';
+};
+type WebTicketsControllerResolveByUserResponses = {
+    /**
+     * Ticket resolved
+     */
+    204: void;
+};
+type WebTicketsControllerResolveByUserResponse = WebTicketsControllerResolveByUserResponses[keyof WebTicketsControllerResolveByUserResponses];
+type WebUploadsControllerUploadData = {
+    body: {
+        /**
+         * Image file (jpeg/png/webp, max 10 MB)
+         */
+        file: Blob | File;
+    };
+    path?: never;
+    query?: never;
+    url: '/web/uploads';
+};
+type WebUploadsControllerUploadResponses = {
+    /**
+     * File uploaded successfully
+     */
+    200: UploadResponseDto;
+};
+type WebUploadsControllerUploadResponse = WebUploadsControllerUploadResponses[keyof WebUploadsControllerUploadResponses];
+type WebUploadsControllerGetUploadData = {
+    body?: never;
+    path: {
+        /**
+         * Upload ID returned by POST /web/uploads
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/web/uploads/{id}';
+};
+type WebUploadsControllerGetUploadResponses = {
+    /**
+     * Image file stream
+     */
+    200: Blob | File;
+};
+type WebUploadsControllerGetUploadResponse = WebUploadsControllerGetUploadResponses[keyof WebUploadsControllerGetUploadResponses];
+
+export type { WebTicketsControllerSendMessageData as A, WebTicketsControllerSendMessageResponse as B, Client as C, WebTicketsControllerSendMessageResponses as D, WebTicketsControllerSseStreamData as E, WebTicketsControllerSseStreamResponse as F, WebTicketsControllerSseStreamResponses as G, WebUploadsControllerGetUploadData as H, IssueTokenDto as I, WebUploadsControllerGetUploadResponse as J, WebUploadsControllerGetUploadResponses as K, WebUploadsControllerUploadData as L, MessageDto as M, WebUploadsControllerUploadResponse as N, Options as O, WebUploadsControllerUploadResponses as P, RequestResult as R, SendMessageDto as S, TDataShape as T, UploadResponseDto as U, WebAuthControllerIssueTokenData as W, ClientOptions as a, ClientOptions$1 as b, Config as c, CurrentTicketResponseDto as d, IssueTokenResponseDto as e, MessagesResponseDto as f, SendMessageResponseDto as g, ServerSentEventsResult as h, TicketInfoDto as i, WebAuthControllerIssueTokenResponse as j, WebAuthControllerIssueTokenResponses as k, WebProfileDto as l, WebSseEventDataDto as m, WebSseEventDto as n, WebTicketsControllerEscalateData as o, WebTicketsControllerEscalateResponse as p, WebTicketsControllerEscalateResponses as q, WebTicketsControllerGetCurrentTicketData as r, WebTicketsControllerGetCurrentTicketResponse as s, WebTicketsControllerGetCurrentTicketResponses as t, WebTicketsControllerGetMessagesData as u, WebTicketsControllerGetMessagesResponse as v, WebTicketsControllerGetMessagesResponses as w, WebTicketsControllerResolveByUserData as x, WebTicketsControllerResolveByUserResponse as y, WebTicketsControllerResolveByUserResponses as z };