@keboola/api-client 27.0.0 → 31.0.0

package/dist/index-Ds8e0l7-.d.ts

@@ -0,0 +1,235 @@
+import * as z$1 from "zod";
+import { IStringifyOptions } from "qs";
+//#region src/errors/ApiError.d.ts
+declare class ApiError extends Error {
+  response: Response;
+  request: Request;
+  data: unknown;
+  constructor({ response, request, data }: ApiResponse);
+}
+//#endregion
+//#region src/fetchClient/createFetchClient/types.d.ts
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options';
+type PathParam = Record<string, string | number>;
+type QueryParam = Record<string, unknown>;
+type BodyParam = Record<string, unknown> | FormData | string | undefined | null | Record<string, unknown>[];
+type ValidateStatusFn = (options: ApiResponse) => boolean | ApiError;
+type CustomRequestInit = Omit<RequestInit, 'method' | 'body'>;
+type FetchFn = typeof fetch;
+type CreateFetchClientOptions = {
+  baseUrl: string;
+  validateStatus?: ValidateStatusFn;
+  middlewares?: MiddlewareFn[];
+  fetchFn?: FetchFn;
+} & CustomRequestInit;
+type FetchClientOptions = {
+  validateStatus?: ValidateStatusFn;
+  queryArrayFormat?: IStringifyOptions['arrayFormat'];
+  middlewares?: MiddlewareFn[];
+  fetchFn?: FetchFn;
+} & CustomRequestInit;
+type ApiResponse<Data = unknown> = {
+  data: Data;
+  response: Response;
+  request: Request;
+};
+type FetchRequest = {
+  request: Request;
+  validateStatus: ValidateStatusFn;
+  fetchFn?: FetchFn;
+};
+type CoreFetchFn = (request: FetchRequest) => Promise<ApiResponse>;
+type MiddlewareFn = (next: CoreFetchFn) => CoreFetchFn;
+//#endregion
+//#region src/errors/HtmlResponseError.d.ts
+/**
+ * A successful response that carried an HTML page instead of the endpoint's payload.
+ *
+ * - Connection answers an expired session with a 302 to the login screen, and `fetch` follows it,
+ *   so the request resolves `200 text/html`.
+ * - Without this the page reaches the caller as a string typed as the endpoint's DTO and fails much
+ *   later, wherever the value is first read — an Immutable accessor on a string, modules away.
+ * - The message stays constant so Sentry groups every occurrence together; `request` and `response`
+ *   carry the per-request detail.
+ * - Raised only by the clients that opt in: some APIs do serve HTML from a 200 on purpose.
+ */
+declare class HtmlResponseError extends ApiError {
+  constructor(res: ApiResponse);
+}
+declare const isHtmlResponseError: (error: unknown) => error is HtmlResponseError;
+//#endregion
+//#region src/errors/ManagementClientAuthError.d.ts
+declare class ManagementClientAuthError extends ApiError {
+  title: string;
+  message: string;
+  constructor(title: string, message: string, res: ApiResponse);
+}
+//#endregion
+//#region src/errors/ValidationError.d.ts
+/**
+ * A payload the SDK refused to accept — an input a caller assembled wrongly, or a response that did
+ * not match the shape the endpoint is documented to return.
+ *
+ * It exists so a `ZodError` never leaves the package. `ZodError.message` is `JSON.stringify` of its
+ * issue list — over a kilobyte for two problems — and a consumer that renders a caught error's
+ * message puts that blob in front of a user. `message` here is a single line built for exactly that
+ * rendering, while `issues` keeps the structured detail for anyone inspecting the failure rather
+ * than displaying it.
+ */
+declare class ValidationError extends Error {
+  issues: z$1.core.$ZodIssue[];
+  constructor(message: string, issues?: z$1.core.$ZodIssue[]);
+}
+declare const isValidationError: (error: unknown) => error is ValidationError;
+/**
+ * Parses with `schema`, converting a `ZodError` into a {@link ValidationError}. Use it instead of a
+ * bare `schema.parse()` anywhere the value crosses the package boundary — every client input and
+ * every response body.
+ */
+declare const parseOrThrow: <T extends z$1.ZodType>(schema: T, value: unknown) => z$1.output<T>;
+//#endregion
+//#region src/fetchClient/createFetchClient/createFetchClient.d.ts
+type FetchClientError = TypeError | ApiError | SyntaxError | DOMException;
+declare const isApiError: (error: unknown) => error is ApiError;
+declare const isAbortError: (error: unknown) => error is DOMException;
+declare const isFetchClientError: (error: unknown) => error is FetchClientError;
+//#endregion
+//#region src/fetchClient/createFetchClient/utils.d.ts
+declare const HttpHeader: {
+  CONTENT_TYPE: string;
+  CONTENT_DISPOSITION: string;
+  AUTHORIZATION: string;
+  IDEMPOTENCY_KEY: string;
+  IF_MATCH: string;
+};
+declare const HttpContentType: {
+  JSON: string;
+  TEXT_PLAIN: string;
+  FORM_DATA: string;
+  TEXT_HTML: string;
+};
+//#endregion
+//#region src/fetchClient/createGenericFetchClient.d.ts
+type FetchParams<Path = PathParam, Query = QueryParam, Body = BodyParam> = {
+  path?: Path;
+  query?: Query;
+  body?: Body;
+};
+type FetchMethod$1 = <Data, Path = PathParam, Query = QueryParam, Body = BodyParam>(url: string, params: FetchParams<Path, Query, Body>, options?: FetchClientOptions) => Promise<ApiResponse<Data>>;
+type FetchClient$1 = {
+  get: FetchMethod$1;
+  post: FetchMethod$1;
+  put: FetchMethod$1;
+  patch: FetchMethod$1;
+  delete: FetchMethod$1;
+};
+declare const createGenericFetchClient: (defaultOptions: CreateFetchClientOptions) => FetchClient$1;
+//#endregion
+//#region src/fetchClient/xhrFetch.d.ts
+type UploadProgress = {
+  loaded: number;
+  total: number;
+  percent: number;
+};
+//#endregion
+//#region src/fetchClient/types.d.ts
+type OpenapiQueryType<Operation> = Operation extends {
+  parameters?: {
+    query?: infer Query;
+  };
+} ? Query : never;
+type OpenapiPathType<Operation> = Operation extends {
+  parameters?: {
+    path?: infer Path;
+  };
+} ? Path : never;
+type HasRequestBody<Operation> = Operation extends {
+  requestBody?: never;
+} ? false : true;
+type HasOptionalBody<Operation> = Operation extends {
+  requestBody: unknown;
+} ? false : true;
+type OpenapiBodyType<Operation> = HasRequestBody<Operation> extends true ? Operation extends {
+  requestBody?: {
+    content: {
+      'application/json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody: {
+    content: {
+      'application/json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody: {
+    content: {
+      'application/vnd.api+json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody?: {
+    content: {
+      'multipart/form-data': unknown;
+    };
+  };
+} ? FormData : Operation extends {
+  requestBody: {
+    content: {
+      'application/x-www-form-urlencoded': infer RequestBody;
+    };
+  };
+} ? RequestBody : never : never;
+/**
+ * The per-field shape of a `multipart/form-data` body — the complement of `OpenapiBodyType`, which
+ * resolves such an operation to the `FormData` that goes on the wire and so cannot report the
+ * fields inside it. Clients derive their input types from this rather than restating the field list.
+ */
+type OpenapiFormDataType<Operation> = Operation extends {
+  requestBody?: {
+    content: {
+      'multipart/form-data': infer Fields;
+    };
+  };
+} ? { [Key in keyof Fields as Key extends `${infer Name}[]` ? Name : Key]: Fields[Key]; } : never;
+type OpenapiBodyParam<Operation> = OpenapiBodyType<Operation> extends never ? {
+  body?: never;
+} : HasOptionalBody<Operation> extends true ? {
+  body?: OpenapiBodyType<Operation>;
+} : {
+  body: OpenapiBodyType<Operation>;
+};
+type InferOpenapiParametersType<Operation> = Operation extends {
+  parameters?: infer P;
+} ? P : never;
+type OpenapiParametersType<Operation> = Omit<InferOpenapiParametersType<Operation>, 'cookie' | 'header'> & OpenapiBodyParam<Operation>;
+type OpenapiResponseTypes<OP> = OP extends {
+  responses: infer R;
+} ? { [S in keyof R]: R[S] extends {
+  content: {
+    'text/plain': infer S;
+  };
+} ? S : R[S] extends {
+  content: {
+    'application/json': infer C;
+  };
+} ? C : S extends 'default' ? R[S] : never; } : never;
+type OpenapiSuccessType<T> = 200 extends keyof T ? T[200] : 201 extends keyof T ? T[201] : 202 extends keyof T ? T[202] : 204 extends keyof T ? T[204] : 'default' extends keyof T ? T['default'] : unknown;
+type OpenapiReturnType<OP> = OpenapiSuccessType<OpenapiResponseTypes<OP>>;
+type ArrayElement<T> = T extends (infer U)[] ? U : never;
+//#endregion
+//#region src/fetchClient/createOpenapiFetchClient.d.ts
+type OpenapiPaths<Paths> = { [P in keyof Paths]: { [M in HttpMethod]?: unknown; }; };
+type PathsWithMethod<Paths extends OpenapiPaths<Paths>, PathnameMethod extends HttpMethod> = { [Pathname in keyof Paths]: Paths[Pathname] extends { [K in PathnameMethod]: any; } ? Pathname : never; }[keyof Paths];
+type FetchMethod<Paths extends OpenapiPaths<Paths>, Method extends HttpMethod> = <Path extends PathsWithMethod<Paths, Method>>(url: Path, params: OpenapiParametersType<Paths[Path][Method]>, options?: FetchClientOptions) => Promise<ApiResponse<OpenapiReturnType<Paths[Path][Method]>>>;
+type FetchClient<Paths extends OpenapiPaths<Paths>> = {
+  get: FetchMethod<Paths, 'get'>;
+  post: FetchMethod<Paths, 'post'>;
+  put: FetchMethod<Paths, 'put'>;
+  patch: FetchMethod<Paths, 'patch'>;
+  delete: FetchMethod<Paths, 'delete'>;
+};
+declare const createOpenapiFetchClient: <Paths extends OpenapiPaths<Paths>>(defaultOptions: CreateFetchClientOptions) => FetchClient<Paths>;
+//#endregion
+export { ApiResponse as C, ApiError as D, ValidateStatusFn as E, isHtmlResponseError as S, MiddlewareFn as T, ValidationError as _, OpenapiParametersType as a, ManagementClientAuthError as b, OpenapiReturnType as c, HttpContentType as d, HttpHeader as f, isFetchClientError as g, isApiError as h, OpenapiFormDataType as i, UploadProgress as l, isAbortError as m, ArrayElement as n, OpenapiPathType as o, FetchClientError as p, OpenapiBodyType as r, OpenapiQueryType as s, createOpenapiFetchClient as t, createGenericFetchClient as u, isValidationError as v, HttpMethod as w, HtmlResponseError as x, parseOrThrow as y };
+//# sourceMappingURL=index-Ds8e0l7-.d.ts.map

package/dist/index-J1I2HlSm.d.ts

@@ -0,0 +1,208 @@
+import { C as ApiResponse } from "./index-Ds8e0l7-.js";
+import { n as ClientInitOptions } from "./types-SX78XZZ0.js";
+import { t as LogEntry } from "./appLogs-BdMG6Cvn.js";
+import { _ as PatchDataAppPath, a as DeleteSandboxPath, c as GetDataAppLogsTailPath, d as GetDataAppPath, f as GetDataAppRunPath, g as PatchDataAppBody, h as GetSandboxPath, i as DeleteDataAppPath, l as GetDataAppLogsTailQuery, m as GetDataAppRunsQuery, o as GetAppsQuery, p as GetDataAppRunsPath, s as GetDataAppLogsDownloadPath, t as CreateDataAppBody, u as GetDataAppPasswordPath, y as ResetDataAppPasswordPath } from "./types-Co8WobOo.js";
+//#region src/clients/dataScience/dataScienceClient.d.ts
+declare const createDataScienceClient: ({ baseUrl, middlewares, auth }: ClientInitOptions) => {
+  healthCheck: (signal?: AbortSignal) => Promise<unknown>;
+  getAppRuns: (appId: GetDataAppRunsPath['appId'], query?: GetDataAppRunsQuery, signal?: AbortSignal) => Promise<{
+    id: string;
+    appId: string;
+    createdAt?: string | null;
+    startedAt?: string | null;
+    stoppedAt?: string | null;
+    startupLogs?: string | null;
+    runtimeSize?: string | null;
+    configVersion?: string | null;
+    failureReason?: {
+      reason?: string | null;
+      message?: string | null;
+    } | null;
+    mode: 'prod' | 'dev';
+    state: "failed" | "finished" | "running" | "starting";
+  }[]>;
+  getAppRun: (appId: GetDataAppRunPath['appId'], runId: GetDataAppRunPath['runId'], signal?: AbortSignal) => Promise<{
+    id: string;
+    appId: string;
+    createdAt?: string | null;
+    startedAt?: string | null;
+    stoppedAt?: string | null;
+    startupLogs?: string | null;
+    runtimeSize?: string | null;
+    configVersion?: string | null;
+    failureReason?: {
+      reason?: string | null;
+      message?: string | null;
+    } | null;
+    mode: 'prod' | 'dev';
+    state: "failed" | "finished" | "running" | "starting";
+  }>;
+  getAppLogsDownload: (id: GetDataAppLogsDownloadPath['appId'], signal?: AbortSignal) => Promise<{
+    logs: string;
+    fileName: string;
+  }>;
+  getAppLogsTail: (id: GetDataAppLogsTailPath['appId'], { query, signal }?: {
+    query?: GetDataAppLogsTailQuery;
+    signal?: AbortSignal;
+  }) => Promise<{
+    entries: LogEntry[];
+    nextLogTimestamp: string | null;
+  }>;
+  getApps: (query: GetAppsQuery, signal?: AbortSignal) => Promise<{
+    id: string;
+    type?: string | null;
+    projectId: string;
+    componentId: string;
+    branchId: string | null;
+    configId: string;
+    configVersion: string;
+    state: 'created' | 'starting' | 'restarting' | 'running' | 'stopping' | 'stopped' | 'deleting' | 'deleted';
+    desiredState: 'running' | 'stopped' | 'deleted';
+    mode: 'prod' | 'dev';
+    lastRequestTimestamp: string | null;
+    lastStartTimestamp?: string | null;
+    url?: string | null;
+    autoSuspendAfterSeconds?: number;
+    autoRestartEnabled?: boolean;
+    size?: string | null;
+    hasManagedGitRepo?: boolean;
+  }[]>;
+  getApp: (appId: GetDataAppPath['appId'], signal?: AbortSignal) => Promise<{
+    id: string;
+    type?: string | null;
+    projectId: string;
+    componentId: string;
+    branchId: string | null;
+    configId: string;
+    configVersion: string;
+    state: 'created' | 'starting' | 'restarting' | 'running' | 'stopping' | 'stopped' | 'deleting' | 'deleted';
+    desiredState: 'running' | 'stopped' | 'deleted';
+    mode: 'prod' | 'dev';
+    lastRequestTimestamp: string | null;
+    lastStartTimestamp?: string | null;
+    url?: string | null;
+    autoSuspendAfterSeconds?: number;
+    autoRestartEnabled?: boolean;
+    size?: string | null;
+    hasManagedGitRepo?: boolean;
+  }>;
+  createApp: (body: CreateDataAppBody, signal?: AbortSignal) => Promise<{
+    id: string;
+    type?: string | null;
+    projectId: string;
+    componentId: string;
+    branchId: string | null;
+    configId: string;
+    configVersion: string;
+    state: 'created' | 'starting' | 'restarting' | 'running' | 'stopping' | 'stopped' | 'deleting' | 'deleted';
+    desiredState: 'running' | 'stopped' | 'deleted';
+    mode: 'prod' | 'dev';
+    lastRequestTimestamp: string | null;
+    lastStartTimestamp?: string | null;
+    url?: string | null;
+    autoSuspendAfterSeconds?: number;
+    autoRestartEnabled?: boolean;
+    size?: string | null;
+    hasManagedGitRepo?: boolean;
+  }>;
+  patchApp: (appId: PatchDataAppPath['appId'], body: PatchDataAppBody, signal?: AbortSignal) => Promise<{
+    id: string;
+    type?: string | null;
+    projectId: string;
+    componentId: string;
+    branchId: string | null;
+    configId: string;
+    configVersion: string;
+    state: 'created' | 'starting' | 'restarting' | 'running' | 'stopping' | 'stopped' | 'deleting' | 'deleted';
+    desiredState: 'running' | 'stopped' | 'deleted';
+    mode: 'prod' | 'dev';
+    lastRequestTimestamp: string | null;
+    lastStartTimestamp?: string | null;
+    url?: string | null;
+    autoSuspendAfterSeconds?: number;
+    autoRestartEnabled?: boolean;
+    size?: string | null;
+    hasManagedGitRepo?: boolean;
+  }>;
+  deleteApp: (appId: DeleteDataAppPath['appId'], signal?: AbortSignal) => Promise<ApiResponse<never>>;
+  getAppPassword: (appId: GetDataAppPasswordPath['appId'], signal?: AbortSignal) => Promise<{
+    password?: string;
+  }>;
+  resetAppPassword: (appId: ResetDataAppPasswordPath['appId'], signal?: AbortSignal) => Promise<{
+    id: string;
+    type?: string | null;
+    projectId: string;
+    componentId: string;
+    branchId: string | null;
+    configId: string;
+    configVersion: string;
+    state: 'created' | 'starting' | 'restarting' | 'running' | 'stopping' | 'stopped' | 'deleting' | 'deleted';
+    desiredState: 'running' | 'stopped' | 'deleted';
+    mode: 'prod' | 'dev';
+    lastRequestTimestamp: string | null;
+    lastStartTimestamp?: string | null;
+    url?: string | null;
+    autoSuspendAfterSeconds?: number;
+    autoRestartEnabled?: boolean;
+    size?: string | null;
+    hasManagedGitRepo?: boolean;
+  }>;
+  getRuntimes: (signal?: AbortSignal) => Promise<{
+    description: string;
+    type: string;
+    isTypeDefault: boolean;
+    releaseDate: string;
+    endOfLifeDate?: string | null;
+    imageName?: string | null;
+    imageTag?: string | null;
+    transformationComponentId?: string | null;
+    transformationComponentTag?: string | null;
+    sandboxImageName?: string | null;
+    sandboxImageTag?: string | null;
+  }[]>;
+  getSandbox: (appId: GetSandboxPath['appId'], signal?: AbortSignal) => Promise<{
+    id?: string;
+    projectId?: string;
+    tokenId?: string;
+    branchId?: string | null;
+    configurationId?: string;
+    physicalId?: string;
+    type?: string;
+    active?: boolean;
+    createdTimestamp?: string;
+    startTimestamp?: string;
+    updatedTimestamp?: string;
+    persistentStorage?: {
+      pvcName?: string | null;
+      k8sManifest?: string | null;
+      isEnabled?: boolean;
+      ready?: boolean | null;
+      k8sStorageClassName?: string | null;
+    };
+    shared?: boolean;
+    componentId?: string;
+    configurationVersion?: string;
+    size?: string | null;
+    lastAutosaveTimestamp?: string | null;
+    expirationTimestamp?: string | null;
+    autoSuspendAfterSeconds?: number;
+    expirationAfterHours?: number;
+    user?: string | null;
+    url?: string | null;
+    password?: string | null;
+    autosaveTokenId?: string | null;
+    host?: string | null;
+    imageVersion?: string | null;
+    packages?: string[] | null;
+    sizeParameters?: unknown;
+    stagingWorkspaceId?: unknown;
+    stagingWorkspaceType?: unknown;
+    workspaceDetails?: unknown;
+    databricks?: unknown;
+    credentials?: unknown;
+  }>;
+  deleteSandbox: (appId: DeleteSandboxPath['appId'], signal?: AbortSignal) => Promise<ApiResponse<never>>;
+};
+//#endregion
+export { createDataScienceClient as t };
+//# sourceMappingURL=index-J1I2HlSm.d.ts.map

package/dist/index-NC1dXRTD.d.cts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+//#region src/utils/keboolaUID.d.ts
+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;
+};
+//#endregion
+//#region src/utils/schemaGuidedMerge.d.ts
+/**
+ * Merge `patch` into `base`, guided by `schema`: descend only through object schemas, merging
+ * key-by-key. At every non-object node — a `z.union` (e.g. Snowflake's password|keypair auth),
+ * an array, or a primitive — the patch REPLACES the base wholesale. That replace is what lets an
+ * update *delete* keys the additive `deepMerge` cannot: switching a credential union to the other
+ * variant drops the abandoned variant's secret, because the entire union subtree is swapped.
+ *
+ * Consequence: a union (or array) subtree is all-or-nothing — the caller must send the complete
+ * block, since a partial patch replaces (and so loses) the omitted siblings.
+ *
+ * Object keys present only in `base` (e.g. `storage`, `processors`, anything the schema omits) are
+ * preserved at every level; `undefined` patch values are skipped. Assumes `patch` is already
+ * schema-validated (so every object-valued patch key has a matching schema node). Pure — neither
+ * argument is mutated.
+ */
+declare const schemaGuidedMerge: <T extends Record<string, unknown>>(schema: z.core.$ZodType, base: T, patch: Record<string, unknown>) => T;
+//#endregion
+export { KeboolaObjectId as n, keboolaUID as r, schemaGuidedMerge as t };
+//# sourceMappingURL=index-NC1dXRTD.d.cts.map

package/dist/index-NC1dXRTD.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+//#region src/utils/keboolaUID.d.ts
+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;
+};
+//#endregion
+//#region src/utils/schemaGuidedMerge.d.ts
+/**
+ * Merge `patch` into `base`, guided by `schema`: descend only through object schemas, merging
+ * key-by-key. At every non-object node — a `z.union` (e.g. Snowflake's password|keypair auth),
+ * an array, or a primitive — the patch REPLACES the base wholesale. That replace is what lets an
+ * update *delete* keys the additive `deepMerge` cannot: switching a credential union to the other
+ * variant drops the abandoned variant's secret, because the entire union subtree is swapped.
+ *
+ * Consequence: a union (or array) subtree is all-or-nothing — the caller must send the complete
+ * block, since a partial patch replaces (and so loses) the omitted siblings.
+ *
+ * Object keys present only in `base` (e.g. `storage`, `processors`, anything the schema omits) are
+ * preserved at every level; `undefined` patch values are skipped. Assumes `patch` is already
+ * schema-validated (so every object-valued patch key has a matching schema node). Pure — neither
+ * argument is mutated.
+ */
+declare const schemaGuidedMerge: <T extends Record<string, unknown>>(schema: z.core.$ZodType, base: T, patch: Record<string, unknown>) => T;
+//#endregion
+export { KeboolaObjectId as n, keboolaUID as r, schemaGuidedMerge as t };
+//# sourceMappingURL=index-NC1dXRTD.d.ts.map

package/dist/index-NicJZIzu.d.ts

@@ -0,0 +1,16 @@
+import { n as ClientInitOptions } from "./types-SX78XZZ0.js";
+import { a as EncryptQuery, s as ScopedSecrets } from "./types-Dirp9mni.js";
+//#region src/clients/encryption/encryptionClient.d.ts
+declare const createEncryptionClient: ({ baseUrl, middlewares }: Omit<ClientInitOptions, 'auth'>) => {
+  healthCheck: (signal?: AbortSignal) => Promise<unknown>;
+  encryptSecrets: <T extends Record<string, unknown>>(data: EncryptQuery & {
+    data: T;
+  }, signal?: AbortSignal) => Promise<T>;
+  encryptScopedSecrets: <T extends Record<string, unknown>>({ scope, ...params }: ScopedSecrets<T>, signal?: AbortSignal) => Promise<T>;
+  encrypt: (data: EncryptQuery & {
+    data: string;
+  }, signal?: AbortSignal) => Promise<string>;
+};
+//#endregion
+export { createEncryptionClient as t };
+//# sourceMappingURL=index-NicJZIzu.d.ts.map