@keboola/api-client 48.0.0 → 50.0.0

package/dist/index-BUZ-vTRt.d.ts

@@ -0,0 +1,150 @@
+import { t as Emitter } from "./emitter-raKkIqRp.js";
+import { z } from "zod";
+type KeboolaObjectType = 'data-catalog' | 'table' | 'bucket' | 'flow' | 'configuration' | 'transformation' | 'data-app' | 'workspace';
+type KeboolaObjectId = {
+  uid: string;
+  type: KeboolaObjectType;
+  projectId: number;
+};
+/**
+ * There is a proposal for a string format to identify objects in Keboola.
+ *
+ * https://keboola.atlassian.net/wiki/spaces/ENGG/pages/3967615431/Keboola+UUID+Format
+ * Unfortunately, this format will not pass BE validation as `:` is not allowed in the `uid`, and the length is limited to 50 characters only.
+ *
+ */
+declare const keboolaUID: {
+  serialize: (input: KeboolaObjectId) => string;
+  deserialize: (input: string) => KeboolaObjectId;
+};
+/**
+ * Merge `patch` into `base`, descending only through object schemas.
+ *
+ * - At a non-object node (union, array, primitive) the patch replaces the base wholesale, so
+ *   switching a union variant drops the old variant's secret.
+ * - Hence a union or array subtree is all-or-nothing: send the complete block.
+ * - Keys only in `base` are kept; `undefined` patch values are skipped.
+ * - Assumes `patch` is schema-validated. Pure.
+ */
+declare const schemaGuidedMerge: <T extends Record<string, unknown>>(schema: z.core.$ZodType, base: T, patch: Record<string, unknown>) => T;
+type Jitter = 'none' | 'full' | 'equal';
+type Backoff = {
+  type: 'constant';
+  interval: number;
+} | {
+  type: 'linear';
+  initialInterval: number;
+  step: number;
+} | {
+  type: 'exponential';
+  initialInterval: number;
+  factor?: number;
+};
+type RandomFn = () => number;
+type BackoffDef = {
+  jitter?: Jitter;
+  maxInterval?: number;
+  random?: RandomFn;
+} & Backoff;
+type Clock = {
+  wait: (ms: number, signal?: AbortSignal) => Promise<void>;
+  now: () => number;
+};
+type PollContext = {
+  attempt: number;
+  elapsed: number;
+};
+/** The context plus the answer it is about: what `until` decides on, and what an ending reports. */
+type PollTick<T> = PollContext & {
+  last: T | null;
+};
+type PollResultState = 'done' | 'timedOut' | 'exhausted' | 'aborted' | 'errored';
+type PollResult<T> = PollTick<T> & ({
+  state: 'done';
+  data: T;
+} | {
+  state: 'timedOut' | 'exhausted';
+  error?: Error;
+} | {
+  state: 'aborted';
+  reason?: unknown;
+} | {
+  state: 'errored';
+  error: Error;
+});
+type PollOptions<T> = {
+  pollFn: (context: PollContext & {
+    signal: AbortSignal;
+  }) => Promise<T>;
+  until: (tick: PollTick<T> & {
+    data: T;
+  }) => boolean;
+  signal?: AbortSignal;
+  backoff?: BackoffDef;
+  isRetryable?: (error: Error) => boolean;
+  maxAttempts?: number;
+  timeout?: number;
+  clock?: Clock;
+};
+type PollKey = readonly unknown[];
+/** `requesting` is the request the poll starts from, before any attempt; `polling` is the attempts. */
+type PollState = 'idle' | 'requesting' | 'polling' | PollResultState;
+type PollSnapshot<T = unknown> = PollTick<T> & {
+  pollKey: PollKey;
+  state: PollState;
+};
+type OnFailure<T> = (result: PollResult<T>, error: Error) => Error | undefined;
+type Poller<T, S = T> = {
+  readonly state: PollState;
+  start: () => Promise<PollResult<T>>;
+  wait: (onFailure?: OnFailure<T>) => Promise<S>;
+  stop: (reason?: string) => void;
+  subscribe: (listener: (snapshot: PollSnapshot<T>) => void) => () => void;
+  debug: () => PollSnapshot<T>;
+};
+type InitRequest<R> = (signal: AbortSignal) => Promise<R>;
+/**
+ * The loop's options plus what names the poll and what it starts from.
+ *
+ * - `pollKey` names the poll; the loop never sees it. Given as a function of `init`, it is what the
+ *   poll started from that names it, once that is known.
+ * - `init` is a value or a request for it (an enqueue), handed to `pollFn`; a request runs first.
+ * - `failed` reads a `done` value for `wait`: what it returns, `wait` throws. A client that
+ *   knows what gets through declares it as `Poller<T, S>` on its own return.
+ */
+type PollerOptions<T, K extends PollKey = PollKey, R = undefined> = Omit<PollOptions<T>, 'pollFn' | 'until'> & {
+  pollKey: K | ((init: R) => K);
+  init?: R | InitRequest<R>;
+  pollFn: (context: PollContext & {
+    init: R;
+    signal: AbortSignal;
+  }) => Promise<T>;
+  until: (tick: PollTick<T> & {
+    data: T;
+  }) => boolean;
+  failed?: (data: T) => Error | undefined;
+};
+type ObservedPoller = Pick<Poller<unknown>, 'stop' | 'subscribe' | 'debug' | 'start'>;
+declare const emitter: Emitter<ObservedPoller>;
+declare const failureOf: (result: PollResult<unknown>) => Error;
+declare const poller: <T, K extends PollKey = PollKey, R = undefined>({ pollKey, init, signal, pollFn, until, failed, ...pollLoopOptions }: PollerOptions<T, K, R>) => Poller<T>;
+type PollEntry = {
+  /** Monotonic, so a list has a key that outlives a re-render. */
+  key: number;
+  startedAt: number;
+  snapshot: PollSnapshot;
+  stop: Poller<unknown>['stop'];
+  start: Poller<unknown>['start'];
+};
+type PollRegistry = {
+  list: () => PollEntry[];
+  subscribe: (listener: () => void) => () => void;
+  clear: () => void;
+  stopAll: (reason?: string) => void;
+  collect: () => void;
+};
+declare const createPollRegistry: ({ limit }?: {
+  limit?: number | undefined;
+}) => PollRegistry;
+export { schemaGuidedMerge as _, PollKey as a, Poller as c, failureOf as d, poller as f, PollTick as g, PollResult as h, ObservedPoller as i, PollerOptions as l, PollOptions as m, PollRegistry as n, PollSnapshot as o, PollContext as p, createPollRegistry as r, PollState as s, PollEntry as t, emitter as u, KeboolaObjectId as v, keboolaUID as y };
+//# sourceMappingURL=index-BUZ-vTRt.d.ts.map

package/dist/{index-DzLXtE4Q.d.ts → index-BZDxWvZW.d.ts}

@@ -1,8 +1,7 @@
-import { ri as ApiResponse } from "./index-sDHBkJhU.js";
-import { n as ClientInitOptions } from "./types-D3H3EAre.js";
-import { t as LogEntry } from "./appLogs-DpcqeOe5.js";
-import { _ as GetSandboxPath, c as GetAppsQuery, d as GetDataAppLogsTailQuery, f as GetDataAppPasswordPath, g as GetDataAppRunsQuery, h as GetDataAppRunsPath, l as GetDataAppLogsDownloadPath, m as GetDataAppRunPath, n as CreateDataAppPreviewLinkPath, o as DeleteDataAppPath, p as GetDataAppPath, s as DeleteSandboxPath, t as CreateDataAppBody, u as GetDataAppLogsTailPath, v as PatchDataAppBody, x as ResetDataAppPasswordPath, y as PatchDataAppPath } from "./types-CfZLdfAL.js";
-//#region src/clients/dataScience/dataScienceClient.d.ts
+import { oi as ApiResponse } from "./index-D1mduJne.js";
+import { n as ClientInitOptions } from "./types-DUpVIuk7.js";
+import { t as LogEntry } from "./appLogs-CTvZAihm.js";
+import { _ as GetSandboxPath, c as GetAppsQuery, d as GetDataAppLogsTailQuery, f as GetDataAppPasswordPath, g as GetDataAppRunsQuery, h as GetDataAppRunsPath, l as GetDataAppLogsDownloadPath, m as GetDataAppRunPath, n as CreateDataAppPreviewLinkPath, o as DeleteDataAppPath, p as GetDataAppPath, s as DeleteSandboxPath, t as CreateDataAppBody, u as GetDataAppLogsTailPath, v as PatchDataAppBody, x as ResetDataAppPasswordPath, y as PatchDataAppPath } from "./types-C9okze_R.js";
 declare const createDataScienceClient: ({ baseUrl, middlewares, auth }: ClientInitOptions) => {
   healthCheck: (signal?: AbortSignal) => Promise<unknown>;
   getAppRuns: (appId: GetDataAppRunsPath['appId'], query?: GetDataAppRunsQuery, signal?: AbortSignal) => Promise<{
@@ -211,6 +210,5 @@ declare const createDataScienceClient: ({ baseUrl, middlewares, auth }: ClientIn
   }>;
   deleteSandbox: (appId: DeleteSandboxPath['appId'], signal?: AbortSignal) => Promise<ApiResponse<never>>;
 };
-//#endregion
 export { createDataScienceClient as t };
-//# sourceMappingURL=index-DzLXtE4Q.d.ts.map
+//# sourceMappingURL=index-BZDxWvZW.d.ts.map