@shukka/sdk 0.0.0-stage → 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,1106 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * 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>;
+}
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+interface ClientMeta {
+}
+
+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$1<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$1<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: 'https://updates.example.com' | (string & {});
+};
+type Error = {
+    error: 'unauthorized' | 'forbidden' | 'not_found' | 'conflict' | 'invalid_request' | 'storage_error' | 'metadata_error' | 'rate_limited';
+    message: string;
+    details?: unknown;
+};
+type AppDetail = {
+    app: {
+        id: number;
+        slug: string;
+        name: string;
+        s3Endpoint: string | null;
+        s3Region: string;
+        s3Bucket: string;
+        s3Prefix: string;
+        s3AccessKeyId: string;
+        s3ForcePathStyle: boolean;
+        releaseLogEnabled: boolean;
+        releaseLogLocales: Array<string>;
+        releaseLogFallbackLocale: string;
+        updaterKind: 'electron' | 'tauri' | 'sparkle';
+        createdAt: number;
+    };
+    channels: Array<{
+        id: number;
+        name: string;
+        currentVersionId: number | null;
+        feedUrl: string;
+        versions: Array<{
+            id: number;
+            appId: number;
+            channelId: number;
+            version: string;
+            createdAt: number;
+            releasedAt: number | null;
+            metadataHits: number;
+            artifactHits: number;
+            isDraft: boolean;
+            isCurrent: boolean;
+            artifacts: Array<{
+                id: number;
+                versionId: number;
+                filename: string;
+                s3Key: string;
+                size: number;
+                kind: 'metadata' | 'artifact';
+            }>;
+        }>;
+    }>;
+    /**
+     * Present only for session actors; omitted when authenticated with an API key.
+     */
+    keys?: Array<{
+        id: number;
+        name: string;
+        hint: string;
+        createdAt: number;
+        lastUsedAt: number | null;
+        revokedAt: number | null;
+    }>;
+};
+type AppUpdated = {
+    app: {
+        id: number;
+        slug: string;
+        name: string;
+        s3Endpoint: string | null;
+        s3Region: string;
+        s3Bucket: string;
+        s3Prefix: string;
+        s3AccessKeyId: string;
+        s3ForcePathStyle: boolean;
+        releaseLogEnabled: boolean;
+        releaseLogLocales: Array<string>;
+        releaseLogFallbackLocale: string;
+        updaterKind: 'electron' | 'tauri' | 'sparkle';
+        createdAt: number;
+    };
+};
+type AppUpdateRequest = {
+    name: string;
+    slug: string;
+    s3Endpoint?: string | null;
+    s3Region: string;
+    s3Bucket: string;
+    s3Prefix?: string;
+    s3AccessKeyId: string;
+    s3SecretAccessKey?: string;
+    s3ForcePathStyle?: boolean;
+    updaterKind?: 'electron' | 'tauri' | 'sparkle';
+};
+type ChannelList = {
+    channels: Array<{
+        id: number;
+        appId: number;
+        name: string;
+        currentVersionId: number | null;
+        createdAt: number;
+    }>;
+};
+type ChannelCreated = {
+    channel: {
+        id: number;
+        appId: number;
+        name: string;
+        currentVersionId: number | null;
+        createdAt: number;
+    };
+};
+type CreateChannelRequest = {
+    name: string;
+};
+type SetCurrentVersionRequest = {
+    /**
+     * Version string, or null to clear current
+     */
+    currentVersion: string | null;
+};
+type ChannelTrend = {
+    granularity: 'hour' | 'day';
+    points: Array<{
+        t: number;
+        metadata: number;
+        artifact: number;
+    }>;
+};
+type VersionTrend = {
+    points: Array<{
+        t: number;
+        metadata: number;
+        artifact: number;
+    }>;
+};
+type EditorNotes = {
+    notes: Array<{
+        locale: string;
+        markdown: string;
+        html: string;
+        text: string;
+        id: number;
+        versionId: number;
+    }>;
+};
+type PublicNotes = {
+    notes: Array<{
+        locale: string;
+        markdown: string;
+        html: string;
+        text: string;
+        version: string;
+        releasedAt: number;
+    }>;
+};
+type SavedNote = {
+    note: {
+        locale: string;
+        markdown: string;
+        html: string;
+        text: string;
+        id: number;
+        versionId: number;
+    };
+};
+type UpsertNoteRequest = {
+    markdown: string;
+};
+type NotesConfigResponse = {
+    releaseLog: {
+        enabled: boolean;
+        locales: Array<string>;
+        fallbackLocale: string;
+    };
+};
+type SaveNotesConfigRequest = {
+    enabled: boolean;
+    locales: Array<string>;
+    fallbackLocale: string;
+};
+type ReleaseMetadata = {
+    /**
+     * Custom JSON object; at most 16 KiB of compact UTF-8 JSON. Public after release.
+     */
+    metadata: {
+        [key: string]: unknown;
+    };
+    version: string;
+};
+type ReplaceReleaseMetadataRequest = {
+    /**
+     * Custom JSON object; at most 16 KiB of compact UTF-8 JSON. Public after release.
+     */
+    metadata: {
+        [key: string]: unknown;
+    };
+};
+type UploadInitResponse = {
+    uploadId: string;
+    expiresAt: number;
+    files: Array<{
+        filename: string;
+        key: string;
+        uploadUrl: string;
+    }>;
+};
+type InitUploadRequest = {
+    app?: string;
+    channel: string;
+    version: string;
+    createChannel?: boolean;
+    files: Array<{
+        filename: string;
+        size?: number;
+    }>;
+};
+type UploadFinalizeResponse = {
+    versionId: number;
+    version: string;
+    channel: string;
+    artifacts: Array<{
+        filename: string;
+        size: number;
+        kind: 'metadata' | 'artifact';
+    }>;
+};
+type FinalizeUploadRequest = {
+    uploadId: string;
+    app?: string;
+    release?: boolean;
+    /**
+     * Custom JSON object; at most 16 KiB of compact UTF-8 JSON. Public after release.
+     */
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+type OkResponse = {
+    ok: true;
+};
+type TauriFeed = {
+    version: string;
+    pub_date: string;
+    platforms: {
+        [key: string]: {
+            url: string;
+            signature: string;
+        };
+    };
+};
+type GetAppData = {
+    body?: never;
+    path: {
+        appSlug: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}';
+};
+type GetAppResponses = {
+    /**
+     * App detail
+     */
+    200: AppDetail;
+};
+type GetAppResponse = GetAppResponses[keyof GetAppResponses];
+type UpdateAppData = {
+    body: AppUpdateRequest;
+    path: {
+        appSlug: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}';
+};
+type UpdateAppResponses = {
+    /**
+     * Updated app
+     */
+    200: AppUpdated;
+};
+type UpdateAppResponse = UpdateAppResponses[keyof UpdateAppResponses];
+type ListChannelsData = {
+    body?: never;
+    path: {
+        appSlug: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels';
+};
+type ListChannelsResponses = {
+    /**
+     * Channel list
+     */
+    200: ChannelList;
+};
+type ListChannelsResponse = ListChannelsResponses[keyof ListChannelsResponses];
+type CreateChannelData = {
+    body: CreateChannelRequest;
+    path: {
+        appSlug: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels';
+};
+type CreateChannelResponses = {
+    /**
+     * Created
+     */
+    201: ChannelCreated;
+};
+type CreateChannelResponse = CreateChannelResponses[keyof CreateChannelResponses];
+type DeleteChannelData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}';
+};
+type DeleteChannelResponses = {
+    /**
+     * Deleted
+     */
+    200: OkResponse;
+};
+type DeleteChannelResponse = DeleteChannelResponses[keyof DeleteChannelResponses];
+type SetCurrentVersionData = {
+    body: SetCurrentVersionRequest;
+    path: {
+        appSlug: string;
+        channel: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}';
+};
+type SetCurrentVersionResponses = {
+    /**
+     * Updated
+     */
+    200: OkResponse;
+};
+type SetCurrentVersionResponse = SetCurrentVersionResponses[keyof SetCurrentVersionResponses];
+type GetChannelTrendData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+    };
+    query?: {
+        range?: 7 | 30 | 90;
+    };
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/trend';
+};
+type GetChannelTrendResponses = {
+    /**
+     * Trend series
+     */
+    200: ChannelTrend;
+};
+type GetChannelTrendResponse = GetChannelTrendResponses[keyof GetChannelTrendResponses];
+type DeleteVersionData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}';
+};
+type DeleteVersionResponses = {
+    /**
+     * Deleted
+     */
+    200: OkResponse;
+};
+type DeleteVersionResponse = DeleteVersionResponses[keyof DeleteVersionResponses];
+type GetArtifactData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+        filename: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/artifacts/{filename}';
+};
+type GetArtifactErrors = {
+    /**
+     * Missing version or file
+     */
+    404: Error;
+};
+type GetArtifactError = GetArtifactErrors[keyof GetArtifactErrors];
+type GetReleaseMetadataData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/metadata';
+};
+type GetReleaseMetadataErrors = {
+    /**
+     * Missing or draft
+     */
+    404: Error;
+};
+type GetReleaseMetadataError = GetReleaseMetadataErrors[keyof GetReleaseMetadataErrors];
+type GetReleaseMetadataResponses = {
+    /**
+     * Version and custom metadata
+     */
+    200: ReleaseMetadata;
+};
+type GetReleaseMetadataResponse = GetReleaseMetadataResponses[keyof GetReleaseMetadataResponses];
+type ReplaceReleaseMetadataData = {
+    body: ReplaceReleaseMetadataRequest;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/metadata';
+};
+type ReplaceReleaseMetadataResponses = {
+    /**
+     * Version and custom metadata
+     */
+    200: ReleaseMetadata;
+};
+type ReplaceReleaseMetadataResponse = ReplaceReleaseMetadataResponses[keyof ReplaceReleaseMetadataResponses];
+type GetVersionTrendData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/trend';
+};
+type GetVersionTrendResponses = {
+    /**
+     * Trend series
+     */
+    200: VersionTrend;
+};
+type GetVersionTrendResponse = GetVersionTrendResponses[keyof GetVersionTrendResponses];
+type GetEditorNotesData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/notes';
+};
+type GetEditorNotesResponses = {
+    /**
+     * Notes
+     */
+    200: EditorNotes;
+};
+type GetEditorNotesResponse = GetEditorNotesResponses[keyof GetEditorNotesResponses];
+type DeleteNoteData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+        locale: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/notes/{locale}';
+};
+type DeleteNoteResponses = {
+    /**
+     * Deleted
+     */
+    200: OkResponse;
+};
+type DeleteNoteResponse = DeleteNoteResponses[keyof DeleteNoteResponses];
+type UpsertNoteData = {
+    body: UpsertNoteRequest;
+    path: {
+        appSlug: string;
+        channel: string;
+        version: string;
+        locale: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/versions/{version}/notes/{locale}';
+};
+type UpsertNoteResponses = {
+    /**
+     * Saved note
+     */
+    200: SavedNote;
+};
+type UpsertNoteResponse = UpsertNoteResponses[keyof UpsertNoteResponses];
+type ListPublicNotesData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+    };
+    query?: {
+        from?: string;
+        to?: string;
+        locale?: string;
+    };
+    url: '/api/v1/apps/{appSlug}/channels/{channel}/notes';
+};
+type ListPublicNotesResponses = {
+    /**
+     * Public notes
+     */
+    200: PublicNotes;
+};
+type ListPublicNotesResponse = ListPublicNotesResponses[keyof ListPublicNotesResponses];
+type SaveNotesConfigData = {
+    body: SaveNotesConfigRequest;
+    path: {
+        appSlug: string;
+    };
+    query?: never;
+    url: '/api/v1/apps/{appSlug}/notes-config';
+};
+type SaveNotesConfigResponses = {
+    /**
+     * Saved config
+     */
+    200: NotesConfigResponse;
+};
+type SaveNotesConfigResponse = SaveNotesConfigResponses[keyof SaveNotesConfigResponses];
+type InitUploadData = {
+    body: InitUploadRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/upload/init';
+};
+type InitUploadResponses = {
+    /**
+     * uploadId and presigned PUT URLs
+     */
+    200: UploadInitResponse;
+};
+type InitUploadResponse = InitUploadResponses[keyof InitUploadResponses];
+type FinalizeUploadData = {
+    body: FinalizeUploadRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/upload/finalize';
+};
+type FinalizeUploadResponses = {
+    /**
+     * Version created
+     */
+    200: UploadFinalizeResponse;
+};
+type FinalizeUploadResponse = FinalizeUploadResponses[keyof FinalizeUploadResponses];
+type GetChannelFeedData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+    };
+    query?: never;
+    url: '/api/update/{appSlug}/{channel}';
+};
+type GetChannelFeedErrors = {
+    /**
+     * Missing or draft
+     */
+    404: Error;
+};
+type GetChannelFeedError = GetChannelFeedErrors[keyof GetChannelFeedErrors];
+type GetChannelFeedResponses = {
+    /**
+     * Generated feed document
+     */
+    200: TauriFeed;
+};
+type GetChannelFeedResponse = GetChannelFeedResponses[keyof GetChannelFeedResponses];
+type GetFeedFileData = {
+    body?: never;
+    path: {
+        appSlug: string;
+        channel: string;
+        filename: string;
+    };
+    query?: never;
+    url: '/api/update/{appSlug}/{channel}/{filename}';
+};
+type GetFeedFileErrors = {
+    /**
+     * Missing or draft
+     */
+    404: Error;
+};
+type GetFeedFileError = GetFeedFileErrors[keyof GetFeedFileErrors];
+type GetFeedFileResponses = {
+    /**
+     * Generated feed document
+     */
+    200: TauriFeed;
+};
+type GetFeedFileResponse = GetFeedFileResponses[keyof GetFeedFileResponses];
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+/**
+ * Get app
+ *
+ * App detail including channels, versions, and keys.
+ */
+declare const getApp: <ThrowOnError extends boolean = false>(options: Options<GetAppData, ThrowOnError>) => RequestResult<GetAppResponses, unknown, ThrowOnError>;
+/**
+ * Update app settings
+ *
+ * Probes S3. API keys may only change `name`. Slug and storage fields are session-only; resubmitting unchanged values is allowed. Changing endpoint/bucket/prefix with existing artifacts probes the newest object at the new location.
+ */
+declare const updateApp: <ThrowOnError extends boolean = false>(options: Options<UpdateAppData, ThrowOnError>) => RequestResult<UpdateAppResponses, unknown, ThrowOnError>;
+/**
+ * List channels
+ */
+declare const listChannels: <ThrowOnError extends boolean = false>(options: Options<ListChannelsData, ThrowOnError>) => RequestResult<ListChannelsResponses, unknown, ThrowOnError>;
+/**
+ * Create a channel
+ */
+declare const createChannel: <ThrowOnError extends boolean = false>(options: Options<CreateChannelData, ThrowOnError>) => RequestResult<CreateChannelResponses, unknown, ThrowOnError>;
+/**
+ * Delete a channel
+ *
+ * Deletes the channel and its objects.
+ */
+declare const deleteChannel: <ThrowOnError extends boolean = false>(options: Options<DeleteChannelData, ThrowOnError>) => RequestResult<DeleteChannelResponses, unknown, ThrowOnError>;
+/**
+ * Set current version
+ *
+ * Promote a draft (`currentVersion`) or roll back to a released version.
+ */
+declare const setCurrentVersion: <ThrowOnError extends boolean = false>(options: Options<SetCurrentVersionData, ThrowOnError>) => RequestResult<SetCurrentVersionResponses, unknown, ThrowOnError>;
+/**
+ * Channel hit trend
+ */
+declare const getChannelTrend: <ThrowOnError extends boolean = false>(options: Options<GetChannelTrendData, ThrowOnError>) => RequestResult<GetChannelTrendResponses, unknown, ThrowOnError>;
+/**
+ * Delete a version
+ *
+ * Deletes the version and its objects.
+ */
+declare const deleteVersion: <ThrowOnError extends boolean = false>(options: Options<DeleteVersionData, ThrowOnError>) => RequestResult<DeleteVersionResponses, unknown, ThrowOnError>;
+/**
+ * Get artifact
+ *
+ * Presigned GET for one artifact on that version (drafts included). Does not increment hits.
+ */
+declare const getArtifact: <ThrowOnError extends boolean = false>(options: Options<GetArtifactData, ThrowOnError>) => RequestResult<unknown, GetArtifactErrors, ThrowOnError>;
+/**
+ * Get release metadata
+ *
+ * Read custom metadata for an exact version. Released versions are public; drafts require a session or bound app key. Explicit Authorization is validated (401/403). Returns no-store and does not increment update checks. Independent of release log.
+ */
+declare const getReleaseMetadata: <ThrowOnError extends boolean = false>(options: Options<GetReleaseMetadataData, ThrowOnError>) => RequestResult<GetReleaseMetadataResponses, GetReleaseMetadataErrors, ThrowOnError>;
+/**
+ * Replace release metadata
+ *
+ * Replace the whole metadata object (16 KiB UTF-8 JSON); {} clears it. Last write wins.
+ */
+declare const replaceReleaseMetadata: <ThrowOnError extends boolean = false>(options: Options<ReplaceReleaseMetadataData, ThrowOnError>) => RequestResult<ReplaceReleaseMetadataResponses, unknown, ThrowOnError>;
+/**
+ * Version hit trend
+ *
+ * Empty for drafts.
+ */
+declare const getVersionTrend: <ThrowOnError extends boolean = false>(options: Options<GetVersionTrendData, ThrowOnError>) => RequestResult<GetVersionTrendResponses, unknown, ThrowOnError>;
+/**
+ * Get editor notes
+ *
+ * Every locale for one version.
+ */
+declare const getEditorNotes: <ThrowOnError extends boolean = false>(options: Options<GetEditorNotesData, ThrowOnError>) => RequestResult<GetEditorNotesResponses, unknown, ThrowOnError>;
+/**
+ * Delete a locale note
+ */
+declare const deleteNote: <ThrowOnError extends boolean = false>(options: Options<DeleteNoteData, ThrowOnError>) => RequestResult<DeleteNoteResponses, unknown, ThrowOnError>;
+/**
+ * Upsert a locale note
+ */
+declare const upsertNote: <ThrowOnError extends boolean = false>(options: Options<UpsertNoteData, ThrowOnError>) => RequestResult<UpsertNoteResponses, unknown, ThrowOnError>;
+/**
+ * Get public notes
+ *
+ * Released versions only; no auth.
+ */
+declare const listPublicNotes: <ThrowOnError extends boolean = false>(options: Options<ListPublicNotesData, ThrowOnError>) => RequestResult<ListPublicNotesResponses, unknown, ThrowOnError>;
+/**
+ * Save notes config
+ *
+ * Saves release-log config without an S3 probe.
+ */
+declare const saveNotesConfig: <ThrowOnError extends boolean = false>(options: Options<SaveNotesConfigData, ThrowOnError>) => RequestResult<SaveNotesConfigResponses, unknown, ThrowOnError>;
+/**
+ * Start upload
+ *
+ * Start a pending upload. Electron requires at least one `.yml`; Tauri requires `latest.json` and/or artifact+`.sig` pairs; Sparkle requires `appcast.xml` and/or archive+`.sig` (see spec).
+ */
+declare const initUpload: <ThrowOnError extends boolean = false>(options: Options<InitUploadData, ThrowOnError>) => RequestResult<InitUploadResponses, unknown, ThrowOnError>;
+/**
+ * Finalize upload
+ *
+ * Creates a version. Default is draft; `release: true` goes live.
+ */
+declare const finalizeUpload: <ThrowOnError extends boolean = false>(options: Options<FinalizeUploadData, ThrowOnError>) => RequestResult<FinalizeUploadResponses, unknown, ThrowOnError>;
+/**
+ * Get channel feed
+ *
+ * Tauri returns JSON; Sparkle returns a one-item appcast.
+ */
+declare const getChannelFeed: <ThrowOnError extends boolean = false>(options: Options<GetChannelFeedData, ThrowOnError>) => RequestResult<GetChannelFeedResponses, GetChannelFeedErrors, ThrowOnError>;
+/**
+ * Get public feed
+ *
+ * Electron yml / Tauri latest.json / Sparkle appcast; artifacts 302. Drafts are 404.
+ */
+declare const getFeedFile: <ThrowOnError extends boolean = false>(options: Options<GetFeedFileData, ThrowOnError>) => RequestResult<GetFeedFileResponses, GetFeedFileErrors, ThrowOnError>;
+
+interface ShukkaClientOptions {
+    /** Instance origin, for example `https://updates.example.com`. */
+    baseUrl: string;
+    /** App-scoped API key (`shk_…`). Omit for the public feed and notes operations. */
+    apiKey?: string;
+    /** Custom fetch implementation (tests, proxies, non-standard runtimes). */
+    fetch?: typeof globalThis.fetch;
+}
+declare function createShukkaClient(options: ShukkaClientOptions): {
+    client: Client;
+    getApp: <T extends boolean = false>(input: Omit<Options<GetAppData, T>, "client">) => RequestResult<GetAppResponses, unknown, T, "fields">;
+    updateApp: <T extends boolean = false>(input: Omit<Options<UpdateAppData, T>, "client">) => RequestResult<UpdateAppResponses, unknown, T, "fields">;
+    listChannels: <T extends boolean = false>(input: Omit<Options<ListChannelsData, T>, "client">) => RequestResult<ListChannelsResponses, unknown, T, "fields">;
+    createChannel: <T extends boolean = false>(input: Omit<Options<CreateChannelData, T>, "client">) => RequestResult<CreateChannelResponses, unknown, T, "fields">;
+    setCurrentVersion: <T extends boolean = false>(input: Omit<Options<SetCurrentVersionData, T>, "client">) => RequestResult<SetCurrentVersionResponses, unknown, T, "fields">;
+    deleteChannel: <T extends boolean = false>(input: Omit<Options<DeleteChannelData, T>, "client">) => RequestResult<DeleteChannelResponses, unknown, T, "fields">;
+    getChannelTrend: <T extends boolean = false>(input: Omit<Options<GetChannelTrendData, T>, "client">) => RequestResult<GetChannelTrendResponses, unknown, T, "fields">;
+    deleteVersion: <T extends boolean = false>(input: Omit<Options<DeleteVersionData, T>, "client">) => RequestResult<DeleteVersionResponses, unknown, T, "fields">;
+    getArtifact: <T extends boolean = false>(input: Omit<Options<GetArtifactData, T>, "client">) => RequestResult<unknown, GetArtifactErrors, T, "fields">;
+    getReleaseMetadata: <T extends boolean = false>(input: Omit<Options<GetReleaseMetadataData, T>, "client">) => RequestResult<GetReleaseMetadataResponses, GetReleaseMetadataErrors, T, "fields">;
+    replaceReleaseMetadata: <T extends boolean = false>(input: Omit<Options<ReplaceReleaseMetadataData, T>, "client">) => RequestResult<ReplaceReleaseMetadataResponses, unknown, T, "fields">;
+    getVersionTrend: <T extends boolean = false>(input: Omit<Options<GetVersionTrendData, T>, "client">) => RequestResult<GetVersionTrendResponses, unknown, T, "fields">;
+    getEditorNotes: <T extends boolean = false>(input: Omit<Options<GetEditorNotesData, T>, "client">) => RequestResult<GetEditorNotesResponses, unknown, T, "fields">;
+    upsertNote: <T extends boolean = false>(input: Omit<Options<UpsertNoteData, T>, "client">) => RequestResult<UpsertNoteResponses, unknown, T, "fields">;
+    deleteNote: <T extends boolean = false>(input: Omit<Options<DeleteNoteData, T>, "client">) => RequestResult<DeleteNoteResponses, unknown, T, "fields">;
+    listPublicNotes: <T extends boolean = false>(input: Omit<Options<ListPublicNotesData, T>, "client">) => RequestResult<ListPublicNotesResponses, unknown, T, "fields">;
+    saveNotesConfig: <T extends boolean = false>(input: Omit<Options<SaveNotesConfigData, T>, "client">) => RequestResult<SaveNotesConfigResponses, unknown, T, "fields">;
+    initUpload: <T extends boolean = false>(input: Omit<Options<InitUploadData, T>, "client">) => RequestResult<InitUploadResponses, unknown, T, "fields">;
+    finalizeUpload: <T extends boolean = false>(input: Omit<Options<FinalizeUploadData, T>, "client">) => RequestResult<FinalizeUploadResponses, unknown, T, "fields">;
+    getChannelFeed: <T extends boolean = false>(input: Omit<Options<GetChannelFeedData, T>, "client">) => RequestResult<GetChannelFeedResponses, GetChannelFeedErrors, T, "fields">;
+    getFeedFile: <T extends boolean = false>(input: Omit<Options<GetFeedFileData, T>, "client">) => RequestResult<GetFeedFileResponses, GetFeedFileErrors, T, "fields">;
+};
+type ShukkaClient = ReturnType<typeof createShukkaClient>;
+
+export { type AppDetail, type AppUpdateRequest, type AppUpdated, type ChannelCreated, type ChannelList, type ChannelTrend, type ClientOptions, type CreateChannelData, type CreateChannelRequest, type CreateChannelResponse, type CreateChannelResponses, type DeleteChannelData, type DeleteChannelResponse, type DeleteChannelResponses, type DeleteNoteData, type DeleteNoteResponse, type DeleteNoteResponses, type DeleteVersionData, type DeleteVersionResponse, type DeleteVersionResponses, type EditorNotes, type Error, type FinalizeUploadData, type FinalizeUploadRequest, type FinalizeUploadResponse, type FinalizeUploadResponses, type GetAppData, type GetAppResponse, type GetAppResponses, type GetArtifactData, type GetArtifactError, type GetArtifactErrors, type GetChannelFeedData, type GetChannelFeedError, type GetChannelFeedErrors, type GetChannelFeedResponse, type GetChannelFeedResponses, type GetChannelTrendData, type GetChannelTrendResponse, type GetChannelTrendResponses, type GetEditorNotesData, type GetEditorNotesResponse, type GetEditorNotesResponses, type GetFeedFileData, type GetFeedFileError, type GetFeedFileErrors, type GetFeedFileResponse, type GetFeedFileResponses, type GetReleaseMetadataData, type GetReleaseMetadataError, type GetReleaseMetadataErrors, type GetReleaseMetadataResponse, type GetReleaseMetadataResponses, type GetVersionTrendData, type GetVersionTrendResponse, type GetVersionTrendResponses, type InitUploadData, type InitUploadRequest, type InitUploadResponse, type InitUploadResponses, type ListChannelsData, type ListChannelsResponse, type ListChannelsResponses, type ListPublicNotesData, type ListPublicNotesResponse, type ListPublicNotesResponses, type NotesConfigResponse, type OkResponse, type Options, type PublicNotes, type ReleaseMetadata, type ReplaceReleaseMetadataData, type ReplaceReleaseMetadataRequest, type ReplaceReleaseMetadataResponse, type ReplaceReleaseMetadataResponses, type SaveNotesConfigData, type SaveNotesConfigRequest, type SaveNotesConfigResponse, type SaveNotesConfigResponses, type SavedNote, type SetCurrentVersionData, type SetCurrentVersionRequest, type SetCurrentVersionResponse, type SetCurrentVersionResponses, type ShukkaClient, type ShukkaClientOptions, type TauriFeed, type UpdateAppData, type UpdateAppResponse, type UpdateAppResponses, type UploadFinalizeResponse, type UploadInitResponse, type UpsertNoteData, type UpsertNoteRequest, type UpsertNoteResponse, type UpsertNoteResponses, type VersionTrend, createChannel, createShukkaClient, deleteChannel, deleteNote, deleteVersion, finalizeUpload, getApp, getArtifact, getChannelFeed, getChannelTrend, getEditorNotes, getFeedFile, getReleaseMetadata, getVersionTrend, initUpload, listChannels, listPublicNotes, replaceReleaseMetadata, saveNotesConfig, setCurrentVersion, updateApp, upsertNote };