@trigger.dev/core 3.0.0-beta.34 → 3.0.0-beta.36

package/dist/v3/zodfetch.d.ts

@@ -0,0 +1,262 @@
+import { z } from 'zod';
+import { R as RetryOptions } from '../schemas-r4ZP9S-F.js';
+import { Readable } from 'node:stream';
+
+interface CursorPageParams {
+    limit?: number;
+    after?: string;
+    before?: string;
+}
+interface OffsetLimitPageParams {
+    limit?: number;
+    page?: number;
+}
+interface PageResponse<Item> {
+    data: Array<Item>;
+}
+interface CursorPageResponse<Item> extends PageResponse<Item> {
+    pagination: {
+        next?: string;
+        previous?: string;
+    };
+}
+interface OffsetLimitPageResponse<Item> extends PageResponse<Item> {
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    };
+}
+interface Page<Item> {
+    getPaginatedItems(): Item[];
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+}
+declare class CursorPage<Item> implements CursorPageResponse<Item>, Page<Item>, AsyncIterable<Item> {
+    private pageFetcher;
+    data: Array<Item>;
+    pagination: {
+        next?: string;
+        previous?: string;
+    };
+    constructor(data: Array<Item>, pagination: {
+        next?: string;
+        previous?: string;
+    }, pageFetcher: (params: Omit<CursorPageParams, "limit">) => Promise<CursorPage<Item>>);
+    getPaginatedItems(): Item[];
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+    getNextPage(): Promise<CursorPage<Item>>;
+    getPreviousPage(): Promise<CursorPage<Item>>;
+    iterPages(): AsyncGenerator<CursorPage<Item>, void, unknown>;
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<Item>, void, unknown>;
+}
+declare class OffsetLimitPage<Item> implements OffsetLimitPageResponse<Item>, Page<Item>, AsyncIterable<Item> {
+    private pageFetcher;
+    data: Array<Item>;
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    };
+    constructor(data: Array<Item>, pagination: {
+        currentPage: number;
+        totalPages: number;
+        count: number;
+    }, pageFetcher: (params: Omit<OffsetLimitPageParams, "limit">) => Promise<OffsetLimitPage<Item>>);
+    getPaginatedItems(): Item[];
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+    getNextPage(): Promise<OffsetLimitPage<Item>>;
+    getPreviousPage(): Promise<OffsetLimitPage<Item>>;
+    iterPages(): AsyncGenerator<OffsetLimitPage<Item>, void, unknown>;
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<Item>, void, unknown>;
+}
+
+declare const defaultRetryOptions: {
+    maxAttempts: number;
+    factor: number;
+    minTimeoutInMs: number;
+    maxTimeoutInMs: number;
+    randomize: false;
+};
+type ZodFetchOptions = {
+    retry?: RetryOptions;
+};
+interface FetchCursorPageParams extends CursorPageParams {
+    query?: URLSearchParams;
+}
+interface FetchOffsetLimitPageParams extends OffsetLimitPageParams {
+    query?: URLSearchParams;
+}
+declare function zodfetch<TResponseBodySchema extends z.ZodTypeAny>(schema: TResponseBodySchema, url: string, requestInit?: RequestInit, options?: ZodFetchOptions): ApiPromise<z.output<TResponseBodySchema>>;
+declare function zodfetchCursorPage<TItemSchema extends z.ZodTypeAny>(schema: TItemSchema, url: string, params: FetchCursorPageParams, requestInit?: RequestInit, options?: ZodFetchOptions): CursorPagePromise<TItemSchema>;
+declare function zodfetchOffsetLimitPage<TItemSchema extends z.ZodTypeAny>(schema: TItemSchema, url: string, params: FetchOffsetLimitPageParams, requestInit?: RequestInit, options?: ZodFetchOptions): OffsetLimitPagePromise<TItemSchema>;
+declare function zodupload<TResponseBodySchema extends z.ZodTypeAny, TBody = Record<string, unknown>>(schema: TResponseBodySchema, url: string, body: TBody, requestInit?: RequestInit, options?: ZodFetchOptions): ApiPromise<z.output<TResponseBodySchema>>;
+type ZodFetchResult<T> = {
+    data: T;
+    response: Response;
+};
+type ToFileInput = Uploadable | Exclude<BlobLikePart, string> | AsyncIterable<BlobLikePart>;
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file.  Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+declare function toFile(value: ToFileInput | PromiseLike<ToFileInput>, name?: string | null | undefined, options?: FilePropertyBag | undefined): Promise<FileLike>;
+/**
+ * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
+ */
+interface BlobLike {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+    readonly size: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+    readonly type: string;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+    text(): Promise<string>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+    slice(start?: number, end?: number): BlobLike;
+}
+/**
+ * Intended to match web.File, node.File, node-fetch.File, etc.
+ */
+interface FileLike extends BlobLike {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+    readonly lastModified: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+    readonly name: string;
+}
+/**
+ * Intended to match web.Response, node.Response, node-fetch.Response, etc.
+ */
+interface ResponseLike {
+    url: string;
+    blob(): Promise<BlobLike>;
+}
+type Uploadable = FileLike | ResponseLike | Readable;
+declare const isResponseLike: (value: any) => value is ResponseLike;
+declare const isFileLike: (value: any) => value is FileLike;
+/**
+ * The BlobLike type omits arrayBuffer() because @types/node-fetch@^2.6.4 lacks it; but this check
+ * adds the arrayBuffer() method type because it is available and used at runtime
+ */
+declare const isBlobLike: (value: any) => value is BlobLike & {
+    arrayBuffer(): Promise<ArrayBuffer>;
+};
+declare const isFsReadStream: (value: any) => value is Readable;
+declare const isUploadable: (value: any) => value is Uploadable;
+type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | Uint8Array | DataView;
+declare const isRecordLike: (value: any) => value is Record<string, string>;
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+declare class ApiPromise<T> extends Promise<T> {
+    private responsePromise;
+    constructor(responsePromise: Promise<ZodFetchResult<T>>);
+    /**
+     * Gets the raw `Response` instance instead of parsing the response
+     * data.
+     *
+     * If you want to parse the response body but still get the `Response`
+     * instance, you can use {@link withResponse()}.
+     */
+    asResponse(): Promise<Response>;
+    /**
+     * Gets the parsed response data and the raw `Response` instance.
+     *
+     * If you just want to get the raw `Response` instance without parsing it,
+     * you can use {@link asResponse()}.
+     */
+    withResponse(): Promise<{
+        data: T;
+        response: Response;
+    }>;
+    private parse;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}
+declare class CursorPagePromise<TItemSchema extends z.ZodTypeAny> extends ApiPromise<CursorPage<z.output<TItemSchema>>> implements AsyncIterable<z.output<TItemSchema>> {
+    #private;
+    private schema;
+    private url;
+    private params;
+    private requestInit?;
+    private options?;
+    constructor(result: Promise<ZodFetchResult<CursorPageResponse<z.output<TItemSchema>>>>, schema: TItemSchema, url: string, params: FetchCursorPageParams, requestInit?: RequestInit | undefined, options?: ZodFetchOptions | undefined);
+    /**
+     * Allow auto-paginating iteration on an unawaited list call, eg:
+     *
+     *    for await (const item of client.items.list()) {
+     *      console.log(item)
+     *    }
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<z.output<TItemSchema>>, void, unknown>;
+}
+declare class OffsetLimitPagePromise<TItemSchema extends z.ZodTypeAny> extends ApiPromise<OffsetLimitPage<z.output<TItemSchema>>> implements AsyncIterable<z.output<TItemSchema>> {
+    #private;
+    private schema;
+    private url;
+    private params;
+    private requestInit?;
+    private options?;
+    constructor(result: Promise<ZodFetchResult<OffsetLimitPageResponse<z.output<TItemSchema>>>>, schema: TItemSchema, url: string, params: FetchOffsetLimitPageParams, requestInit?: RequestInit | undefined, options?: ZodFetchOptions | undefined);
+    /**
+     * Allow auto-paginating iteration on an unawaited list call, eg:
+     *
+     *    for await (const item of client.items.list()) {
+     *      console.log(item)
+     *    }
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<z.output<TItemSchema>>, void, unknown>;
+}
+
+type APIHeaders = Record<string, string | null | undefined>;
+declare class ApiError extends Error {
+    readonly status: number | undefined;
+    readonly headers: APIHeaders | undefined;
+    readonly error: Object | undefined;
+    readonly code: string | null | undefined;
+    readonly param: string | null | undefined;
+    readonly type: string | undefined;
+    constructor(status: number | undefined, error: Object | undefined, message: string | undefined, headers: APIHeaders | undefined);
+    private static makeMessage;
+    static generate(status: number | undefined, errorResponse: Object | undefined, message: string | undefined, headers: APIHeaders | undefined): ApiError;
+}
+declare class ApiConnectionError extends ApiError {
+    readonly status: undefined;
+    constructor({ message, cause }: {
+        message?: string;
+        cause?: Error | undefined;
+    });
+}
+declare class BadRequestError extends ApiError {
+    readonly status: 400;
+}
+declare class AuthenticationError extends ApiError {
+    readonly status: 401;
+}
+declare class PermissionDeniedError extends ApiError {
+    readonly status: 403;
+}
+declare class NotFoundError extends ApiError {
+    readonly status: 404;
+}
+declare class ConflictError extends ApiError {
+    readonly status: 409;
+}
+declare class UnprocessableEntityError extends ApiError {
+    readonly status: 422;
+}
+declare class RateLimitError extends ApiError {
+    readonly status: 429;
+}
+declare class InternalServerError extends ApiError {
+}
+
+export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, AuthenticationError, BadRequestError, type BlobLike, type BlobLikePart, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, type FileLike, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, type ResponseLike, type ToFileInput, UnprocessableEntityError, type Uploadable, type ZodFetchOptions, defaultRetryOptions, isBlobLike, isFileLike, isFsReadStream, isRecordLike, isResponseLike, isUploadable, toFile, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage, zodupload };