@keboola/api-client 25.0.0 → 29.0.0

package/dist/index-BthgbVdd.d.ts

@@ -0,0 +1,31 @@
+import { t as createOpenapiFetchClient } from "./index-8pN6Emos.js";
+import { n as ClientInitOptions } from "./types-7H6Dnz0Y.js";
+import { D as components, O as paths, S as ReplaceTargetProjectsInput, T as UpdateMetaObjectInput, c as DeleteMetaObjectRevisionPath, d as GetMetaObjectRevisionsPath, f as GetMetaObjectsPath, g as MetaStoreObjectResponse, h as MetaStoreListResponse, i as CreateMetaObjectInput, l as GetMetaObjectPath, n as GetVersionedSchemaPath, s as DeleteMetaObjectPath, t as GetSchemaPath, u as GetMetaObjectRevisionPath, y as ReplaceMetaObjectInput } from "./types-Z-vUwgym.js";
+//#region src/clients/metastore/metastoreClient.d.ts
+type MetastoreFetchClient = ReturnType<typeof createOpenapiFetchClient<paths>>;
+declare const createMetastoreClient: ({ baseUrl, middlewares, auth }: ClientInitOptions) => {
+  healthCheck: (signal?: AbortSignal) => Promise<unknown>;
+  repository: {
+    getMetaObjects: <TData extends Record<string, unknown>>(input: GetMetaObjectsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
+    getMetaObjectRevisions: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
+    getMetaObject: <TData extends Record<string, unknown>>(input: GetMetaObjectPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
+    createMetaObject: <TData extends Record<string, unknown>>({ objectType, data, ...body }: CreateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    deleteMetaObject: (input: DeleteMetaObjectPath) => Promise<never>;
+    updateMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: UpdateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    replaceMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: ReplaceMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    replaceTargetProjects: ({ objectType, UUID, ...body }: ReplaceTargetProjectsInput) => Promise<void>;
+    getMetaObjectRevision: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
+    deleteMetaObjectRevision: (input: DeleteMetaObjectRevisionPath) => Promise<never>;
+  };
+  schema: {
+    getSchema: (input: GetSchemaPath, signal?: AbortSignal) => Promise<{
+      versions?: components['schemas']['models.SchemaInfo'][];
+    }>;
+    getVersionedSchema: (input: GetVersionedSchemaPath, signal?: AbortSignal) => Promise<{
+      [key: string]: unknown;
+    }>;
+  };
+};
+//#endregion
+export { createMetastoreClient as n, MetastoreFetchClient as t };
+//# sourceMappingURL=index-BthgbVdd.d.ts.map

package/dist/index-CLPrlyIz.d.cts

@@ -0,0 +1,218 @@
+import { IStringifyOptions } from "qs";
+import * as z$1 from "zod";
+//#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/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 { MiddlewareFn as C, HttpMethod as S, ApiError 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, ValidateStatusFn as w, ApiResponse as x, parseOrThrow as y };
+//# sourceMappingURL=index-CLPrlyIz.d.cts.map

package/dist/index-CXQRvZ-f.d.cts

@@ -0,0 +1,31 @@
+import { t as createOpenapiFetchClient } from "./index-CLPrlyIz.cjs";
+import { n as ClientInitOptions } from "./types-C8XiTXxi.cjs";
+import { D as components, O as paths, S as ReplaceTargetProjectsInput, T as UpdateMetaObjectInput, c as DeleteMetaObjectRevisionPath, d as GetMetaObjectRevisionsPath, f as GetMetaObjectsPath, g as MetaStoreObjectResponse, h as MetaStoreListResponse, i as CreateMetaObjectInput, l as GetMetaObjectPath, n as GetVersionedSchemaPath, s as DeleteMetaObjectPath, t as GetSchemaPath, u as GetMetaObjectRevisionPath, y as ReplaceMetaObjectInput } from "./types-DMvU4kZ2.cjs";
+//#region src/clients/metastore/metastoreClient.d.ts
+type MetastoreFetchClient = ReturnType<typeof createOpenapiFetchClient<paths>>;
+declare const createMetastoreClient: ({ baseUrl, middlewares, auth }: ClientInitOptions) => {
+  healthCheck: (signal?: AbortSignal) => Promise<unknown>;
+  repository: {
+    getMetaObjects: <TData extends Record<string, unknown>>(input: GetMetaObjectsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
+    getMetaObjectRevisions: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionsPath, signal?: AbortSignal) => Promise<MetaStoreListResponse<TData>>;
+    getMetaObject: <TData extends Record<string, unknown>>(input: GetMetaObjectPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
+    createMetaObject: <TData extends Record<string, unknown>>({ objectType, data, ...body }: CreateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    deleteMetaObject: (input: DeleteMetaObjectPath) => Promise<never>;
+    updateMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: UpdateMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    replaceMetaObject: <TData extends Record<string, unknown>>({ objectType, UUID, data, ...body }: ReplaceMetaObjectInput<TData>) => Promise<MetaStoreObjectResponse<TData>>;
+    replaceTargetProjects: ({ objectType, UUID, ...body }: ReplaceTargetProjectsInput) => Promise<void>;
+    getMetaObjectRevision: <TData extends Record<string, unknown>>(input: GetMetaObjectRevisionPath, signal?: AbortSignal) => Promise<MetaStoreObjectResponse<TData>>;
+    deleteMetaObjectRevision: (input: DeleteMetaObjectRevisionPath) => Promise<never>;
+  };
+  schema: {
+    getSchema: (input: GetSchemaPath, signal?: AbortSignal) => Promise<{
+      versions?: components['schemas']['models.SchemaInfo'][];
+    }>;
+    getVersionedSchema: (input: GetVersionedSchemaPath, signal?: AbortSignal) => Promise<{
+      [key: string]: unknown;
+    }>;
+  };
+};
+//#endregion
+export { createMetastoreClient as n, MetastoreFetchClient as t };
+//# sourceMappingURL=index-CXQRvZ-f.d.cts.map