@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/v3/zodfetch.d.ts

@@ -0,0 +1,219 @@
+import { z } from 'zod';
+import { R as RetryOptions } from '../schemas-C9ssfehv.js';
+import { Attributes, Span } from '@opentelemetry/api';
+import { T as TriggerTracer } from '../tracer-N0p2Fuuv.js';
+import '@opentelemetry/api-logs';
+
+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;
+    tracer?: TriggerTracer;
+    name?: string;
+    attributes?: Attributes;
+    icon?: string;
+    onResponseBody?: (body: unknown, span: Span) => void;
+};
+type ApiRequestOptions = Pick<ZodFetchOptions, "retry">;
+declare const isRequestOptions: (obj: unknown) => obj is ApiRequestOptions;
+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>;
+type ZodFetchResult<T> = {
+    data: T;
+    response: Response;
+};
+/**
+ * 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>;
+}
+declare function isEmptyObj(obj: Object | null | undefined): boolean;
+declare function hasOwn(obj: Object, key: string): boolean;
+
+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;
+    get millisecondsUntilReset(): number | undefined;
+}
+declare class InternalServerError extends ApiError {
+}
+
+export { type APIHeaders, ApiConnectionError, ApiError, ApiPromise, type ApiRequestOptions, AuthenticationError, BadRequestError, ConflictError, CursorPage, type CursorPageParams, CursorPagePromise, type CursorPageResponse, InternalServerError, NotFoundError, OffsetLimitPage, type OffsetLimitPageParams, OffsetLimitPagePromise, type OffsetLimitPageResponse, type Page, type PageResponse, PermissionDeniedError, RateLimitError, UnprocessableEntityError, type ZodFetchOptions, defaultRetryOptions, hasOwn, isEmptyObj, isRequestOptions, zodfetch, zodfetchCursorPage, zodfetchOffsetLimitPage };