@spatialwalk/avatarkit 1.0.0-beta.36 → 1.0.0-beta.38

package/dist/admin/src/apis/useCollectionTaskApi.d.ts

@@ -0,0 +1,64 @@
+export declare function useCollectionTaskApi(): {
+    listCollectionTasks: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+        collectionTaskStatuses?: number[];
+        nameSearch?: string;
+        creatorIds?: string[];
+        timeRangeStart?: string;
+        timeRangeEnd?: string;
+        expiresTimeRangeStart?: string;
+        expiresTimeRangeEnd?: string;
+    }) => Promise<{
+        collectionTasks: Array<import('../client').V1CollectionTask>;
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getCollectionTask: (id: string) => Promise<{
+        collectionTask: import('../client').V1CollectionTask;
+        shareUrl: string;
+    }>;
+    createCollectionTask: (taskData: {
+        name: string;
+        description: string;
+        expiresAt?: string;
+    }) => Promise<{
+        collectionTask: import('../client').V1CollectionTask;
+        shareUrl: string;
+    }>;
+    updateCollectionTask: (id: string, taskData: {
+        name?: string;
+        description?: string;
+    }) => Promise<{
+        collectionTask: import('../client').V1CollectionTask;
+        shareUrl: string;
+    }>;
+    deleteCollectionTask: (id: string) => Promise<{
+        [x: string]: unknown;
+    }>;
+    getCollectionTaskByToken: (token: string) => Promise<{
+        collectionTask: import('../client').V1CollectionTask;
+    }>;
+    getCollectionTaskOSSCredentials: (token: string, resourcePath: string) => Promise<{
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string;
+        expiration: string;
+        region: string;
+        bucketName: string;
+        provider: string;
+        baseUrl: string;
+        accountId: string;
+    }>;
+    submitCollectionFile: (params: {
+        token: string;
+        fileUrl: string;
+        fileType: string;
+        r2Key: string;
+        duration?: number;
+        resolution?: string;
+        fileSize?: number;
+    }) => Promise<{
+        materialId: string;
+        message: string;
+    }>;
+};

package/dist/admin/src/apis/useConfigApi.d.ts

@@ -0,0 +1,16 @@
+import { ConfigKV, CreateConfigKVRequest, ListConfigKVsParams, ListConfigKVsResponse, UpdateConfigKVRequest } from '../types/config';
+
+export declare function useConfigApi(): {
+    isLoading: import('vue').Ref<boolean, boolean>;
+    createConfig: (request: CreateConfigKVRequest) => Promise<ConfigKV>;
+    getConfig: (id: string) => Promise<ConfigKV>;
+    getConfigByKey: (key: string) => Promise<ConfigKV | null>;
+    updateConfig: (request: UpdateConfigKVRequest) => Promise<ConfigKV>;
+    deleteConfig: (id: string) => Promise<void>;
+    listConfigs: (params?: ListConfigKVsParams) => Promise<ListConfigKVsResponse>;
+    getConfigOptions: () => Promise<Array<{
+        value: string;
+        label: string;
+        config: ConfigKV;
+    }>>;
+};

package/dist/admin/src/apis/useConsoleApi.d.ts

@@ -0,0 +1,24 @@
+export declare function useConsoleApi(): {
+    listApps: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+    }) => Promise<{
+        apps: Array<import('../client').V1App>;
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getApp: (appId: string) => Promise<{
+        app: import('../client').V1App;
+    }>;
+    createApp: (name: string) => Promise<{
+        appId: string;
+    }>;
+    deleteApp: (appId: string) => Promise<{
+        [x: string]: unknown;
+    }>;
+    createAPIKey: (appId: string) => Promise<{
+        apiKey: import('../client').V1ApiKey;
+    }>;
+    deleteAPIKey: (appId: string, apiKey: string) => Promise<{
+        [x: string]: unknown;
+    }>;
+};

package/dist/admin/src/apis/useGpuTaskApi.d.ts

@@ -0,0 +1,41 @@
+import { V1CreateGpuTaskRequest, V1GpuTask, V1GpuTaskStats, V1GpuTaskStatus, V1GpuTaskType } from '../client/types.gen';
+export type { V1GpuTask as GpuTask, V1GpuTaskStats as GpuTaskStats, V1GpuTaskStatus as GpuTaskStatus, V1GpuTaskType as GpuTaskType };
+
+export declare function useGpuTaskApi(): {
+    listGpuTasks: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+        taskTypes?: V1GpuTaskType[];
+        statuses?: V1GpuTaskStatus[];
+        refId?: string;
+        search?: string;
+        timeRangeStart?: string;
+        timeRangeEnd?: string;
+    }) => Promise<{
+        gpuTasks: V1GpuTask[];
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getGpuTask: (id: string) => Promise<{
+        gpuTask: V1GpuTask;
+    }>;
+    createGpuTask: (params: V1CreateGpuTaskRequest) => Promise<{
+        gpuTask: V1GpuTask;
+    }>;
+    retryGpuTask: (id: string) => Promise<{
+        gpuTask: V1GpuTask;
+    }>;
+    cancelGpuTask: (id: string) => Promise<{
+        gpuTask: V1GpuTask;
+    }>;
+    getGpuTaskStats: (taskType?: V1GpuTaskType) => Promise<{
+        stats: V1GpuTaskStats;
+    }>;
+    listOssFiles: (prefix: string) => Promise<{
+        files: string[];
+        total: number;
+    }>;
+    getGpuTaskLogs: (id: string) => Promise<{
+        logs: string;
+        gongjiStatus: string;
+    }>;
+};

package/dist/admin/src/apis/useInstanceManagementApi.d.ts

@@ -0,0 +1,19 @@
+import { ContainerImage, LaunchTemplate, ListContainerImagesResponse, ListContainerImageTagsResponse, ListLaunchTemplatesResponse } from '../../generated/platform/v1/instance_management';
+export interface LaunchTemplateOption {
+    value: string;
+    label: string;
+    template: LaunchTemplate;
+}
+export interface ContainerImageOption {
+    value: string;
+    label: string;
+    image: ContainerImage;
+}
+
+export declare function useInstanceManagementApi(): {
+    fetchLaunchTemplates: (tagKey?: string) => Promise<ListLaunchTemplatesResponse>;
+    fetchContainerImages: (source?: string) => Promise<ListContainerImagesResponse>;
+    fetchContainerImageTags: (repositoryName: string, source?: string) => Promise<ListContainerImageTagsResponse>;
+    transformLaunchTemplatesToOptions: (templates?: LaunchTemplate[]) => LaunchTemplateOption[];
+    transformContainerImagesToOptions: (images?: ContainerImage[]) => ContainerImageOption[];
+};

package/dist/admin/src/apis/useJoiModelApplyApi.d.ts

@@ -0,0 +1,11 @@
+import { V1ListJoiModelAppliesResponse } from '../client';
+export interface ListJoiModelAppliesParams {
+    pageSize?: number;
+    pageToken?: string;
+    appUserId?: string;
+    statuses?: Array<'JOI_MODEL_APPLY_STATUS_UNSPECIFIED' | 'JOI_MODEL_APPLY_STATUS_PENDING' | 'JOI_MODEL_APPLY_STATUS_GENERATING_AVATAR' | 'JOI_MODEL_APPLY_STATUS_AVATAR_READY' | 'JOI_MODEL_APPLY_STATUS_GENERATING_VIDEO' | 'JOI_MODEL_APPLY_STATUS_VIDEO_READY' | 'JOI_MODEL_APPLY_STATUS_TRAINING_MODEL' | 'JOI_MODEL_APPLY_STATUS_MODEL_READY' | 'JOI_MODEL_APPLY_STATUS_COMPLETED' | 'JOI_MODEL_APPLY_STATUS_FAILED'>;
+}
+
+export declare function useJoiModelApplyApi(): {
+    listJoiModelApplies: (params?: ListJoiModelAppliesParams) => Promise<V1ListJoiModelAppliesResponse>;
+};

package/dist/admin/src/apis/useMaterialApi.d.ts

@@ -0,0 +1 @@
+export { useVideoMaterialApi as useMaterialApi } from './useVideoMaterialApi';

package/dist/admin/src/apis/useOssApi.d.ts

@@ -0,0 +1,15 @@
+export interface OSSCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    expiration?: string;
+    region: string;
+    bucketName: string;
+    provider: string;
+    baseUrl: string;
+    accountId?: string;
+}
+
+export declare function useOssApi(): {
+    getOSSCredentials: (resourcePath: string, durationSeconds?: number) => Promise<OSSCredentials>;
+};

package/dist/admin/src/apis/usePipelineTemplateApi.d.ts

@@ -0,0 +1,8 @@
+import { CreatePipeTemplateRequest, CreatePipeTemplateResponse, DeletePipeTemplateRequest, DeletePipeTemplateResponse, GetPipeTemplateRequest, GetPipeTemplateResponse, ListPipeTemplatesRequest, ListPipeTemplatesResponse, UpdatePipeTemplateRequest, UpdatePipeTemplateResponse } from '../../generated/platform/v1/pipetemplate';
+export declare function usePipelineTemplateApi(): {
+    listPipeTemplates: (params?: ListPipeTemplatesRequest) => Promise<ListPipeTemplatesResponse>;
+    createPipelineTemplate: (data: CreatePipeTemplateRequest) => Promise<CreatePipeTemplateResponse>;
+    getPipelineTemplate: (params: GetPipeTemplateRequest) => Promise<GetPipeTemplateResponse>;
+    updatePipelineTemplate: (data: UpdatePipeTemplateRequest) => Promise<UpdatePipeTemplateResponse>;
+    deletePipelineTemplate: (params: DeletePipeTemplateRequest) => Promise<DeletePipeTemplateResponse>;
+};

package/dist/admin/src/apis/useProviderApi.d.ts

@@ -0,0 +1,16 @@
+import { V1Provider } from '../client';
+
+export declare function useProviderApi(): {
+    listProviders: (params?: {
+        pageSize?: number;
+        pageToken?: string;
+        type?: string;
+    }) => Promise<{
+        providers: V1Provider[];
+        pagination?: {
+            nextPageToken?: string;
+            totalCount?: number;
+        };
+    }>;
+    getProvider: (id: string) => Promise<V1Provider | null>;
+};

package/dist/admin/src/apis/useRedeemApi.d.ts

@@ -0,0 +1,5 @@
+export declare function useRedeemApi(): {
+    createRedeem: (characterId: string) => Promise<import('../client').V1Redeem>;
+    getRedeem: (characterId: string) => Promise<import('../client').V1Redeem | null>;
+    updateRedeem: (characterId: string, enabled: boolean) => Promise<import('../client').V1Redeem>;
+};

package/dist/admin/src/apis/useSmsSendLogApi.d.ts

@@ -0,0 +1,14 @@
+import { V1ListSmsSendLogsResponse } from '../client';
+export interface ListSmsSendLogsParams {
+    pageSize?: number;
+    pageToken?: string;
+    countryCode?: string;
+    phoneNumber?: string;
+    scenes?: Array<'SMS_SCENE_UNSPECIFIED' | 'SMS_SCENE_LOGIN' | 'SMS_SCENE_OTHER'>;
+    statuses?: Array<'SMS_STATUS_UNSPECIFIED' | 'SMS_STATUS_PENDING' | 'SMS_STATUS_SUCCESS' | 'SMS_STATUS_FAILED'>;
+    isUsed?: boolean;
+}
+
+export declare function useSmsSendLogApi(): {
+    listSmsSendLogs: (params?: ListSmsSendLogsParams) => Promise<V1ListSmsSendLogsResponse>;
+};

package/dist/admin/src/apis/useTaskApi.d.ts

@@ -0,0 +1,66 @@
+import { V1TaskResolution, V1TaskType } from '../client/types.gen';
+
+export declare function useTaskApi(): {
+    listTasks: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+        pipeTemplateId?: string;
+        materialId?: string;
+        taskStatuses?: number[];
+        taskTypes?: number[];
+        creatorSearch?: string;
+        timeRangeStart?: string;
+        timeRangeEnd?: string;
+    }) => Promise<{
+        tasks: Array<import('../client').V1Task>;
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getTask: (id: string) => Promise<import('../client').V1Task>;
+    createTask: (taskData: {
+        name?: string;
+        taskType?: V1TaskType;
+        pipeTemplateId?: string;
+        materialId: string;
+        data?: Record<string, unknown>;
+        resolution?: V1TaskResolution;
+    }) => Promise<import('../client').V1Task>;
+    updateTask: (id: string, taskData: {
+        name?: string;
+        pipeTemplateId?: string;
+        materialId?: string;
+        data?: Record<string, unknown>;
+    }) => Promise<import('../client').V1Task>;
+    deleteTask: (id: string) => Promise<{
+        [x: string]: unknown;
+    }>;
+    terminateTaskInstances: (id: string) => Promise<{
+        terminatedInstances: Array<string>;
+        failedInstances: Array<string>;
+        message: string;
+    }>;
+};
+
+export declare function useStatusApi(): {
+    listStatuses: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+        taskId?: string;
+        status?: string;
+    }) => Promise<{
+        statuses: Array<import('../client').Consolev1Status>;
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getStatus: (id: string) => Promise<import('../client').Consolev1Status>;
+    createStatus: (statusData: {
+        taskId: string;
+        status: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<import('../client').Consolev1Status>;
+    updateStatus: (id: string, statusData: {
+        status?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<import('../client').Consolev1Status>;
+    deleteStatus: (id: string) => Promise<{
+        [x: string]: unknown;
+    }>;
+};

package/dist/admin/src/apis/useUserApi.d.ts

@@ -0,0 +1,17 @@
+import { UserServiceUpdateUserBody } from '../client/types.gen';
+
+export declare function useUserApi(): {
+    listUsers: (options?: {
+        pageSize?: number;
+        pageToken?: string;
+    }) => Promise<{
+        users: Array<import('../client').V1User>;
+        pagination: import('../client').V1PaginationResponse;
+    }>;
+    getUser: (id: string) => Promise<{
+        user: import('../client').V1User;
+    }>;
+    updateUser: (id: string, userData: UserServiceUpdateUserBody) => Promise<{
+        user: import('../client').V1User;
+    }>;
+};

package/dist/admin/src/apis/useVoiceApi.d.ts

@@ -0,0 +1,15 @@
+import { AudioData, ListVoicesParams, ListVoicesResponse, TrainVoiceRequest, Voice } from '../types/voice';
+
+export declare function useVoiceApi(): {
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fileToAudioData: (file: File, text: string) => Promise<AudioData>;
+    trainVoice: (request: TrainVoiceRequest) => Promise<Voice>;
+    getVoiceTrainingStatus: (id: string) => Promise<Voice>;
+    getVoice: (id: string) => Promise<Voice>;
+    listVoices: (params?: ListVoicesParams) => Promise<ListVoicesResponse>;
+    getVoiceOptions: () => Promise<Array<{
+        value: string;
+        label: string;
+        voice: Voice;
+    }>>;
+};

package/dist/admin/src/client/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import { Client, Config } from './types.gen';
+export declare const createClient: (config?: Config) => Client;

package/dist/admin/src/client/client/index.d.ts

@@ -0,0 +1,8 @@
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/dist/admin/src/client/client/types.gen.d.ts

@@ -0,0 +1,70 @@
+import { Auth } from '../core/auth.gen';
+import { ServerSentEventsOptions, ServerSentEventsResult } from '../core/serverSentEvents.gen';
+import { Client as CoreClient, Config as CoreConfig } from '../core/types.gen';
+import { Middleware } from './utils.gen';
+export type ResponseStyle = 'data' | 'fields';
+export interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, CoreConfig {
+    baseUrl?: T['baseUrl'];
+    fetch?: typeof fetch;
+    next?: never;
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    responseStyle?: ResponseStyle;
+    throwOnError?: T['throwOnError'];
+}
+export 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>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+export 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: Request;
+    response: Response;
+}>;
+export interface ClientOptions {
+    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<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+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;
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+export interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+export 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'>);
+export {};

package/dist/admin/src/client/client/utils.gen.d.ts

@@ -0,0 +1,31 @@
+import { QuerySerializerOptions } from '../core/bodySerializer.gen';
+import { Client, ClientOptions, Config, RequestOptions } from './types.gen';
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
+
+export declare const getParseAs: (contentType: string | null) => Exclude<Config["parseAs"], "auto">;
+export declare const setAuthParams: ({ security, ...options }: Pick<Required<RequestOptions>, "security"> & Pick<RequestOptions, "auth" | "query"> & {
+    headers: Headers;
+}) => Promise<void>;
+export declare const buildUrl: Client['buildUrl'];
+export declare const mergeConfigs: (a: Config, b: Config) => Config;
+export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, 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;
+}
+export interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+export declare const createInterceptors: <Req, Res, Err, Options>() => Middleware<Req, Res, Err, Options>;
+export declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
+export {};

package/dist/admin/src/client/client.gen.d.ts

@@ -0,0 +1,5 @@
+import { ClientOptions, Config } from './client';
+import { ClientOptions as ClientOptions2 } from './types.gen';
+
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+export declare const client: import('./client').Client;

package/dist/admin/src/client/core/auth.gen.d.ts

@@ -0,0 +1,8 @@
+export type AuthToken = string | undefined;
+export interface Auth {
+    in?: 'header' | 'query' | 'cookie';
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+export declare const getAuthToken: (auth: Auth, callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken) => Promise<string | undefined>;

package/dist/admin/src/client/core/bodySerializer.gen.d.ts

@@ -0,0 +1,21 @@
+import { ArrayStyle, ObjectStyle, SerializerOptions } from './pathSerializer.gen';
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+export type BodySerializer = (body: any) => any;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+export declare const formDataBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
+};
+export declare const jsonBodySerializer: {
+    bodySerializer: <T>(body: T) => string;
+};
+export declare const urlSearchParamsBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
+};
+export {};

package/dist/admin/src/client/core/params.gen.d.ts

@@ -0,0 +1,27 @@
+type Slot = 'body' | 'headers' | 'path' | 'query';
+export type Field = {
+    in: Exclude<Slot, 'body'>;
+    key: string;
+    map?: string;
+} | {
+    in: Extract<Slot, 'body'>;
+    key?: string;
+    map?: string;
+} | {
+
+    key: string;
+    map: Slot;
+};
+export interface Fields {
+    allowExtra?: Partial<Record<Slot, boolean>>;
+    args?: ReadonlyArray<Field>;
+}
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+interface Params {
+    body: unknown;
+    headers: Record<string, unknown>;
+    path: Record<string, unknown>;
+    query: Record<string, unknown>;
+}
+export declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
+export {};

package/dist/admin/src/client/core/pathSerializer.gen.d.ts

@@ -0,0 +1,30 @@
+interface SerializeOptions<T> extends SerializePrimitiveOptions, SerializerOptions<T> {
+}
+interface SerializePrimitiveOptions {
+    allowReserved?: boolean;
+    name: string;
+}
+export interface SerializerOptions<T> {
+    explode: boolean;
+    style: T;
+}
+export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = 'label' | 'matrix' | 'simple';
+export type ObjectStyle = 'form' | 'deepObject';
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+    value: string;
+}
+export declare const separatorArrayExplode: (style: ArraySeparatorStyle) => "." | ";" | "," | "&";
+export declare const separatorArrayNoExplode: (style: ArraySeparatorStyle) => "," | "|" | "%20";
+export declare const separatorObjectExplode: (style: ObjectSeparatorStyle) => "." | ";" | "," | "&";
+export declare const serializeArrayParam: ({ allowReserved, explode, name, style, value, }: SerializeOptions<ArraySeparatorStyle> & {
+    value: unknown[];
+}) => string;
+export declare const serializePrimitiveParam: ({ allowReserved, name, value, }: SerializePrimitiveParam) => string;
+export declare const serializeObjectParam: ({ allowReserved, explode, name, style, value, valueOnly, }: SerializeOptions<ObjectSeparatorStyle> & {
+    value: Record<string, unknown> | Date;
+    valueOnly?: boolean;
+}) => string;
+export {};

package/dist/admin/src/client/core/queryKeySerializer.gen.d.ts

@@ -0,0 +1,9 @@
+export type JsonValue = null | string | number | boolean | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+
+export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => {} | null | undefined;
+
+export declare const stringifyToJsonValue: (input: unknown) => JsonValue | undefined;
+
+export declare const serializeQueryKeyValue: (value: unknown) => JsonValue | undefined;

package/dist/admin/src/client/core/serverSentEvents.gen.d.ts

@@ -0,0 +1,23 @@
+import { Config } from './types.gen';
+export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    fetch?: typeof fetch;
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    onSseError?: (error: unknown) => void;
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    sseDefaultRetryDelay?: number;
+    sseMaxRetryAttempts?: number;
+    sseMaxRetryDelay?: number;
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+export interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;

package/dist/admin/src/client/core/types.gen.d.ts

@@ -0,0 +1,32 @@
+import { Auth, AuthToken } from './auth.gen';
+import { BodySerializer, QuerySerializer, QuerySerializerOptions } from './bodySerializer.gen';
+export type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+export type Client<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+export interface Config {
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    bodySerializer?: BodySerializer | null;
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    method?: Uppercase<HttpMethod>;
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never] ? true : [T] extends [never | undefined] ? [undefined] extends [T] ? false : true : false;
+export type OmitNever<T extends Record<string, unknown>> = {
+    [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];
+};
+export {};