@keboola/api-client 32.0.0 → 34.0.0

package/dist/types-fX4gbxfV.d.cts

@@ -0,0 +1,218 @@
+import { i as CreateMetaObjectInput } from "./types-Cz83RiVu.cjs";
+import { n as createMetastoreClient } from "./index-DXSmFkol.cjs";
+//#region src/sdks/semanticLayer/vocabulary.d.ts
+/**
+ * The closed value sets the metastore accepts inside a semantic object's `data`.
+ *
+ * - Each one is the single runtime source for a union in `./types`, which derives the type from
+ *   the array here. A value cannot exist in the type and be missing from the list a dropdown or
+ *   a validator is built from.
+ * - The addressing vocabulary (`SEMANTIC_OBJECT_TYPE`, `MODEL_CHILD_OBJECT_TYPES`) is a
+ *   different axis — which object a call targets, not what may sit inside one — and stays beside
+ *   the SDK methods that take it.
+ * - This file imports nothing: `./types` reads it, never the reverse.
+ */
+/**
+ * The dialects the metastore accepts, exactly as it spells them. A lowercase value is
+ * rejected with `422 value must be one of 'Snowflake', 'BigQuery'`, which surfaces only as a
+ * generic "Validation failed" — so callers need the real set rather than a bare `string`.
+ *
+ * `SemanticModelData.sql_dialect` stays `string` for now: narrowing it would break any caller
+ * passing a `string` variable, which is a major bump. Validate against this instead.
+ */
+declare const SQL_DIALECTS: readonly ['Snowflake', 'BigQuery'];
+/** The metastore's constraint kinds. */
+declare const CONSTRAINT_TYPES: readonly ['inequality', 'equality', 'range', 'composition', 'exclusion', 'temporal', 'conditional'];
+/**
+ * What a dataset field is for.
+ *
+ * - Enumerated, unlike a field's `type`: the metastore takes any type string, but only these
+ *   four roles.
+ */
+declare const FIELD_ROLES: readonly ['key', 'dimension', 'measure', 'timestamp'];
+/**
+ * How loudly a violated constraint reports.
+ *
+ * - An unset severity is stored as `warning`, so a reader renders that rather than nothing.
+ */
+declare const CONSTRAINT_SEVERITIES: readonly ['error', 'warning', 'info'];
+/**
+ * What a constraint's rule is evaluated per.
+ *
+ * - An unset scope is stored as `global`.
+ */
+declare const CONSTRAINT_SCOPES: readonly ['global', 'per_location', 'per_date', 'per_category'];
+/** The comparisons a constraint's `ruleExpression` can make. */
+declare const RULE_OPERATORS: readonly ['<', '<=', '=', '>=', '>', '!=', 'between', 'in', 'sum_equals', 'ratio_between'];
+/** The join a relationship stands for. */
+declare const RELATIONSHIP_JOIN_TYPES: readonly ['left', 'inner'];
+//#endregion
+//#region src/sdks/semanticLayer/types.d.ts
+type MetastoreClient = ReturnType<typeof createMetastoreClient>;
+/**
+ * Every union below is derived from its list in `./vocabulary` rather than spelled out again.
+ *
+ * - A value the metastore starts accepting is added in one place, and the type, the validators
+ *   and every dropdown built from the list follow.
+ * - Deriving in this direction keeps this module type-only: the import is `import type`, so the
+ *   `./sdk/semanticLayer/types` entry point stays free of runtime code.
+ */
+type SemanticFieldRole = (typeof FIELD_ROLES)[number];
+type SemanticAiMetadata = {
+  synonyms?: string[];
+  keywords?: string[];
+  antiKeywords?: string[];
+  hints?: string[];
+  warnings?: string[];
+};
+type SemanticModelData = {
+  name: string;
+  description?: string;
+  sql_dialect: string;
+};
+type SemanticFieldData = {
+  name: string;
+  description?: string;
+  type?: string;
+  role?: SemanticFieldRole;
+  values?: string[];
+  ai?: SemanticAiMetadata;
+};
+type SemanticDatasetData = {
+  modelUUID: string;
+  name: string;
+  tableId: string;
+  fqn: string;
+  description?: string;
+  grain?: string;
+  primaryKey?: string[];
+  fields?: SemanticFieldData[];
+  ai?: SemanticAiMetadata;
+};
+type SemanticMetricData = {
+  modelUUID: string;
+  name: string;
+  sql: string;
+  dataset?: string;
+  description?: string;
+};
+type SemanticRelationshipData = {
+  modelUUID: string;
+  name?: string;
+  from: string;
+  to: string;
+  on: string;
+  type?: SemanticRelationshipJoinType;
+};
+type SemanticGlossaryData = {
+  modelUUID: string;
+  term: string;
+  definition: string;
+  seeAlso?: string[];
+};
+type SemanticConstraintType = (typeof CONSTRAINT_TYPES)[number];
+type SemanticConstraintScope = (typeof CONSTRAINT_SCOPES)[number];
+type SemanticConstraintSeverity = (typeof CONSTRAINT_SEVERITIES)[number];
+type SemanticRuleOperator = (typeof RULE_OPERATORS)[number];
+type SemanticRelationshipJoinType = (typeof RELATIONSHIP_JOIN_TYPES)[number];
+type SemanticRuleExpression = {
+  operator?: SemanticRuleOperator;
+  left?: string;
+  right?: string;
+  bounds?: {
+    min?: number;
+    max?: number;
+  };
+};
+type SemanticValidationQuery = {
+  default?: string;
+  snowflake?: string;
+  bigquery?: string;
+};
+type SemanticConstraintData = {
+  modelUUID: string;
+  name: string;
+  displayName?: string;
+  description?: string;
+  constraintType: SemanticConstraintType;
+  metrics: string[];
+  datasets?: string[];
+  rule: string;
+  ruleExpression?: SemanticRuleExpression;
+  validationQuery?: SemanticValidationQuery;
+  severity?: SemanticConstraintSeverity;
+  errorMessage?: string;
+  remediation?: string;
+  isActive?: boolean;
+  scope?: SemanticConstraintScope;
+  owner?: string;
+  tags?: string[];
+};
+type SemanticChildObjectDataMap = {
+  'semantic-dataset': SemanticDatasetData;
+  'semantic-metric': SemanticMetricData;
+  'semantic-relationship': SemanticRelationshipData;
+  'semantic-glossary': SemanticGlossaryData;
+  'semantic-constraint': SemanticConstraintData;
+};
+type SemanticChildObjectType = keyof SemanticChildObjectDataMap;
+type SemanticObjectType = SemanticChildObjectType | 'semantic-model';
+type SemanticObjectMeta = {
+  name?: string;
+  branch?: string;
+  projectId?: number;
+  organizationId?: string;
+  revision?: number;
+  schemaVersion?: string;
+  createdAt?: string;
+  lastUpdated?: string;
+  revisionCreatedAt?: string;
+};
+/**
+ * Normalized metastore object as returned by this SDK. Matches the live metastore
+ * envelope ({ type, id, attributes: <data payload>, meta: {...} }), which differs
+ * from the legacy wrapper types in clients/metastore/repository/types.ts.
+ */
+type SemanticObject<TData> = {
+  uuid: string;
+  data: TData;
+  meta: SemanticObjectMeta;
+};
+type CreateSemanticObjectMeta = Omit<CreateMetaObjectInput, 'data' | 'objectType'>;
+/**
+ * Meta for a CONTENT update. `scope` is deliberately absent: a scope change is a separate PATCH
+ * shape the metastore refuses to combine with name/data (see UpdateMetaObjectInput's union), and
+ * it used to be accepted here — compiling fine and failing with a 400 on every live call.
+ */
+type UpdateSemanticObjectMeta = {
+  name?: string;
+};
+/**
+ * One child of a model as `listModelChildren` reports it: enough to address it (type + UUID)
+ * and to label it for a user (`name` is the display label, see `deriveObjectLabel`).
+ */
+type SemanticModelChildRef = {
+  objectType: SemanticChildObjectType;
+  objectUUID: string;
+  name: string | undefined;
+};
+/**
+ * An object a read could not parse, as far as the raw envelope can be trusted to say.
+ *
+ * - `objectUUID` is `null` when the envelope carries no usable `id` — such an object cannot be
+ *   addressed at all, through this SDK or any other caller of it.
+ * - `modelUUID` is `null` when that field is itself part of what failed to parse, which means the
+ *   object cannot be attributed to a model and has to be counted against every one of them.
+ */
+type SemanticUnreadableObjectRef = {
+  objectType: SemanticObjectType;
+  objectUUID: string | null;
+  modelUUID: string | null;
+};
+/** A child `deleteModel` tried and failed to delete, with the error that delete rejected with. */
+type SemanticModelChildDeleteFailure = SemanticModelChildRef & {
+  error: unknown;
+};
+//#endregion
+export { CONSTRAINT_TYPES as A, SemanticRuleExpression as C, UpdateSemanticObjectMeta as D, SemanticValidationQuery as E, RELATIONSHIP_JOIN_TYPES as M, RULE_OPERATORS as N, CONSTRAINT_SCOPES as O, SQL_DIALECTS as P, SemanticRelationshipJoinType as S, SemanticUnreadableObjectRef as T, SemanticModelData as _, SemanticChildObjectType as a, SemanticObjectType as b, SemanticConstraintSeverity as c, SemanticFieldData as d, SemanticFieldRole as f, SemanticModelChildRef as g, SemanticModelChildDeleteFailure as h, SemanticChildObjectDataMap as i, FIELD_ROLES as j, CONSTRAINT_SEVERITIES as k, SemanticConstraintType as l, SemanticMetricData as m, MetastoreClient as n, SemanticConstraintData as o, SemanticGlossaryData as p, SemanticAiMetadata as r, SemanticConstraintScope as s, CreateSemanticObjectMeta as t, SemanticDatasetData as u, SemanticObject as v, SemanticRuleOperator as w, SemanticRelationshipData as x, SemanticObjectMeta as y };
+//# sourceMappingURL=types-fX4gbxfV.d.cts.map

package/dist/types-g3vU7hcg.d.cts

@@ -0,0 +1,289 @@
+import { c as OpenapiReturnType, r as OpenapiBodyType } from "./index-V7XKUQm9.cjs";
+//#region src/clients/telemetry/__generated__/schema.d.ts
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+type paths = {
+  '/health': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Health check endpoint
+     * @description Returns the health status of the service
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Service is healthy */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'text/plain': string;
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Root endpoint
+     * @description Returns OK
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Successful response */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'text/plain': string;
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/token': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Exchange Storage API token for a signed JWT
+     * @description Validates the provided Keboola Storage API master token and returns a signed
+     *     ES256 JWT (expires in 1 hour) that can be used to authenticate with the
+     *     embed telemetry Data App via Authorization Bearer header.
+     *     JWT claims: sub, project_id, stack_id, role, project_type, iat, exp.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          'application/json': components['schemas']['TokenParameters'];
+        };
+      };
+      responses: {
+        /** @description JWT token successfully issued */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['TokenResponse'];
+          };
+        };
+        /** @description Missing or invalid Storage API token */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content?: never;
+        };
+        /** @description Token is not a master token */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content?: never;
+        };
+        /** @description JWT signing key not configured or signing error */
+        500: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content?: never;
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/.well-known/jwks.json': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * JSON Web Key Set endpoint
+     * @description Returns the public key(s) used to verify JWTs issued by the /token endpoint.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description JWKS response */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['JWKSResponse'];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/.well-known/public-key.pem': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Public key in PEM format
+     * @description Returns the JWT signing public key in PEM format for consumers
+     *     that don't support JWKS.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description PEM-encoded public key */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/x-pem-file': string;
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+};
+type components = {
+  schemas: {
+    TokenParameters: {
+      /**
+       * @description Project type passed through as-is into the JWT project_type claim.
+       *     Examples: "production", "payAsYouGo", "payAsYouGoBigQuery".
+       *     If omitted, the claim is set to an empty string.
+       * @example payAsYouGo
+       */
+      project_type?: string;
+    };
+    TokenResponse: {
+      /**
+       * @description Signed ES256 JWT (expires in 1 hour)
+       * @example eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9...
+       */
+      token?: string;
+      /**
+       * Format: date-time
+       * @description Token expiration time in RFC 3339 format (1 hour after issuance)
+       * @example 2024-01-15T13:00:00Z
+       */
+      expires_at?: string;
+    };
+    JWKSResponse: {
+      keys?: {
+        /** @example EC */
+        kty?: string;
+        /** @example P-256 */
+        crv?: string;
+        /** @description Base64url-encoded X coordinate */
+        x?: string;
+        /** @description Base64url-encoded Y coordinate */
+        y?: string;
+        /** @description Key ID derived from SHA-256 of DER-encoded public key */
+        kid?: string;
+        /** @example sig */
+        use?: string;
+        /** @example ES256 */
+        alg?: string;
+      }[];
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+};
+//#endregion
+//#region src/clients/telemetry/types.d.ts
+/** `project_type` is a free-form passthrough into the JWT claim — the service validates it nowhere. */
+type GetProvisioningTokenBody = NonNullable<OpenapiBodyType<paths['/token']['post']>>;
+type ProvisioningToken = OpenapiReturnType<paths['/token']['post']>;
+//#endregion
+export { ProvisioningToken as n, GetProvisioningTokenBody as t };
+//# sourceMappingURL=types-g3vU7hcg.d.cts.map

package/dist/{types-D-qI9ne4.d.ts → types-l9o4gFsI.d.ts}

@@ -1,4 +1,4 @@
-import { c as OpenapiReturnType, n as ArrayElement, o as OpenapiPathType, r as OpenapiBodyType, s as OpenapiQueryType } from "./index-CeJOmN-P.js";
+import { c as OpenapiReturnType, n as ArrayElement, o as OpenapiPathType, r as OpenapiBodyType, s as OpenapiQueryType } from "./index-KuQ79Mnz.js";
 //#region src/clients/vault/__generated__/schema.d.ts
 /**
  * This file was auto-generated by openapi-typescript.
@@ -383,4 +383,4 @@ type VariableWithHash = Omit<VariableWithHashRaw, 'hash'> & {
 type AnyVariable = VariableWithHash | CreateVariableBody;
 //#endregion
 export { GetVariablesQuery as a, GetVariablesByBranchId as i, CreateVariableBody as n, VariableWithHash as o, DeleteVariablePath as r, AnyVariable as t };
-//# sourceMappingURL=types-D-qI9ne4.d.ts.map
+//# sourceMappingURL=types-l9o4gFsI.d.ts.map

package/dist/{types-EJEoI3ZK.d.ts → types-nrviNdzZ.d.ts}

@@ -1,4 +1,4 @@
-import { i as OpenapiFormDataType } from "./index-CeJOmN-P.js";
+import { i as OpenapiFormDataType } from "./index-KuQ79Mnz.js";
 //#region src/clients/import/__generated__/schema.d.ts
 /**
  * This file was auto-generated by openapi-typescript.
@@ -460,4 +460,4 @@ type WriteTableInput = Omit<WriteTableFormData, 'data'> & {
 };
 //#endregion
 export { WriteTableInput as n, UploadFileInput as t };
-//# sourceMappingURL=types-EJEoI3ZK.d.ts.map
+//# sourceMappingURL=types-nrviNdzZ.d.ts.map

package/dist/{types-BTbczawY.d.ts → types-zZBxJ0P-.d.ts}

@@ -1,4 +1,4 @@
-import { c as OpenapiReturnType, o as OpenapiPathType, r as OpenapiBodyType, s as OpenapiQueryType } from "./index-CeJOmN-P.js";
+import { c as OpenapiReturnType, o as OpenapiPathType, r as OpenapiBodyType, s as OpenapiQueryType } from "./index-KuQ79Mnz.js";
 //#region src/clients/scheduler/__generated__/schema.d.ts
 /**
  * This file was auto-generated by openapi-typescript.
@@ -370,4 +370,4 @@ type SchedulePath = OpenapiPathType<paths['/schedules/{scheduleId}']['get']>;
 type ConfigurationPath = OpenapiPathType<paths['/configurations/{configurationId}']['delete']>;
 //#endregion
 export { SchedulePath as a, Schedule as i, ConfigurationPath as n, Schedules as o, GetSchedulesQuery as r, ActivateScheduleBody as t };
-//# sourceMappingURL=types-BTbczawY.d.ts.map
+//# sourceMappingURL=types-zZBxJ0P-.d.ts.map

package/dist/{validateConnectionStatus-V9q6Nl6u.cjs → validateConnectionStatus-CsvYmCOI.cjs}

@@ -1,4 +1,5 @@
-const require_createFetchClient = require("./createFetchClient-BRfTjBLV.cjs");
+const require_createFetchClient = require("./createFetchClient-DgMiqTJ8.cjs");
+const require_isLoginPageRedirect = require("./isLoginPageRedirect-B0EmRsHr.cjs");
 //#region src/errors/HtmlResponseError.ts
 /**
 * A successful response that carried an HTML page instead of the endpoint's payload.
@@ -23,13 +24,13 @@ const isHtmlResponseError = (error) => error instanceof HtmlResponseError;
 /**
 * Status validation for the APIs Connection serves off its own host — storage and auth.
 *
-* - Rejects a successful response carrying an HTML page; `HtmlResponseError` says why.
+* - Rejects a successful login page; `HtmlResponseError` says why.
 * - HTML on a *failed* response is a real error page and stays an `ApiError`.
 * - Management answers the same condition with its own session-expiry error instead.
 */
 const validateConnectionStatus = (apiResponse) => {
 	const isValid = require_createFetchClient.defaultValidateStatus(apiResponse);
-	if (isValid && require_createFetchClient.isHtmlResponse(apiResponse)) return new HtmlResponseError(apiResponse);
+	if (isValid && require_isLoginPageRedirect.isLoginPageRedirect(apiResponse)) return new HtmlResponseError(apiResponse);
 	return isValid;
 };
 //#endregion
@@ -52,4 +53,4 @@ Object.defineProperty(exports, "validateConnectionStatus", {
 	}
 });
 
-//# sourceMappingURL=validateConnectionStatus-V9q6Nl6u.cjs.map
+//# sourceMappingURL=validateConnectionStatus-CsvYmCOI.cjs.map

package/dist/validateConnectionStatus-CsvYmCOI.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateConnectionStatus-CsvYmCOI.cjs","names":["ApiError","defaultValidateStatus","isLoginPageRedirect"],"sources":["../src/errors/HtmlResponseError.ts","../src/clients/validateConnectionStatus.ts"],"sourcesContent":["import type { ApiResponse } from '../fetchClient/createFetchClient/types';\n\nimport { ApiError } from './ApiError';\n\n/**\n * A successful response that carried an HTML page instead of the endpoint's payload.\n *\n * - Connection answers an expired session with a 302 to the login screen, and `fetch` follows it,\n *   so the request resolves `200 text/html`.\n * - Without this the page reaches the caller as a string typed as the endpoint's DTO and fails much\n *   later, wherever the value is first read — an Immutable accessor on a string, modules away.\n * - The message stays constant so Sentry groups every occurrence together; `request` and `response`\n *   carry the per-request detail.\n * - Raised only by the clients that opt in: some APIs do serve HTML from a 200 on purpose.\n */\nexport class HtmlResponseError extends ApiError {\n  constructor(res: ApiResponse) {\n    super(res);\n    this.message = 'Expected data, got an HTML page. The session has most likely expired.';\n  }\n}\n\nexport const isHtmlResponseError = (error: unknown): error is HtmlResponseError =>\n  error instanceof HtmlResponseError;\n","import { HtmlResponseError } from '../errors';\nimport { defaultValidateStatus, type ValidateStatusFn } from '../fetchClient';\n\nimport { isLoginPageRedirect } from './isLoginPageRedirect';\n\n/**\n * Status validation for the APIs Connection serves off its own host — storage and auth.\n *\n * - Rejects a successful login page; `HtmlResponseError` says why.\n * - HTML on a *failed* response is a real error page and stays an `ApiError`.\n * - Management answers the same condition with its own session-expiry error instead.\n */\nexport const validateConnectionStatus: ValidateStatusFn = (apiResponse) => {\n  const isValid = defaultValidateStatus(apiResponse);\n\n  if (isValid && isLoginPageRedirect(apiResponse)) {\n    return new HtmlResponseError(apiResponse);\n  }\n\n  return isValid;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,oBAAb,cAAuCA,0BAAAA,SAAS;CAC9C,YAAY,KAAkB;EAC5B,MAAM,GAAG;EACT,KAAK,UAAU;CACjB;AACF;AAEA,MAAa,uBAAuB,UAClC,iBAAiB;;;;;;;;;;ACXnB,MAAa,4BAA8C,gBAAgB;CACzE,MAAM,UAAUC,0BAAAA,sBAAsB,WAAW;CAEjD,IAAI,WAAWC,4BAAAA,oBAAoB,WAAW,GAC5C,OAAO,IAAI,kBAAkB,WAAW;CAG1C,OAAO;AACT"}

package/dist/{validateConnectionStatus-BrLXkoSI.js → validateConnectionStatus-olE2sQ3U.js}

@@ -1,4 +1,5 @@
-import { c as isHtmlResponse, m as ApiError, s as defaultValidateStatus } from "./createFetchClient-BbG46bL0.js";
+import { c as defaultValidateStatus, g as ApiError } from "./createFetchClient-U-ZrwPl2.js";
+import { t as isLoginPageRedirect } from "./isLoginPageRedirect-BTTAedW-.js";
 //#region src/errors/HtmlResponseError.ts
 /**
 * A successful response that carried an HTML page instead of the endpoint's payload.
@@ -23,16 +24,16 @@ const isHtmlResponseError = (error) => error instanceof HtmlResponseError;
 /**
 * Status validation for the APIs Connection serves off its own host — storage and auth.
 *
-* - Rejects a successful response carrying an HTML page; `HtmlResponseError` says why.
+* - Rejects a successful login page; `HtmlResponseError` says why.
 * - HTML on a *failed* response is a real error page and stays an `ApiError`.
 * - Management answers the same condition with its own session-expiry error instead.
 */
 const validateConnectionStatus = (apiResponse) => {
 	const isValid = defaultValidateStatus(apiResponse);
-	if (isValid && isHtmlResponse(apiResponse)) return new HtmlResponseError(apiResponse);
+	if (isValid && isLoginPageRedirect(apiResponse)) return new HtmlResponseError(apiResponse);
 	return isValid;
 };
 //#endregion
 export { HtmlResponseError as n, isHtmlResponseError as r, validateConnectionStatus as t };
 
-//# sourceMappingURL=validateConnectionStatus-BrLXkoSI.js.map
+//# sourceMappingURL=validateConnectionStatus-olE2sQ3U.js.map

package/dist/{validateConnectionStatus-BrLXkoSI.js.map → validateConnectionStatus-olE2sQ3U.js.map}

@@ -1 +1 @@
-{"version":3,"file":"validateConnectionStatus-BrLXkoSI.js","names":[],"sources":["../src/errors/HtmlResponseError.ts","../src/clients/validateConnectionStatus.ts"],"sourcesContent":["import type { ApiResponse } from '../fetchClient/createFetchClient/types';\n\nimport { ApiError } from './ApiError';\n\n/**\n * A successful response that carried an HTML page instead of the endpoint's payload.\n *\n * - Connection answers an expired session with a 302 to the login screen, and `fetch` follows it,\n *   so the request resolves `200 text/html`.\n * - Without this the page reaches the caller as a string typed as the endpoint's DTO and fails much\n *   later, wherever the value is first read — an Immutable accessor on a string, modules away.\n * - The message stays constant so Sentry groups every occurrence together; `request` and `response`\n *   carry the per-request detail.\n * - Raised only by the clients that opt in: some APIs do serve HTML from a 200 on purpose.\n */\nexport class HtmlResponseError extends ApiError {\n  constructor(res: ApiResponse) {\n    super(res);\n    this.message = 'Expected data, got an HTML page. The session has most likely expired.';\n  }\n}\n\nexport const isHtmlResponseError = (error: unknown): error is HtmlResponseError =>\n  error instanceof HtmlResponseError;\n","import { HtmlResponseError } from '../errors';\nimport { defaultValidateStatus, isHtmlResponse, type ValidateStatusFn } from '../fetchClient';\n\n/**\n * Status validation for the APIs Connection serves off its own host — storage and auth.\n *\n * - Rejects a successful response carrying an HTML page; `HtmlResponseError` says why.\n * - HTML on a *failed* response is a real error page and stays an `ApiError`.\n * - Management answers the same condition with its own session-expiry error instead.\n */\nexport const validateConnectionStatus: ValidateStatusFn = (apiResponse) => {\n  const isValid = defaultValidateStatus(apiResponse);\n\n  if (isValid && isHtmlResponse(apiResponse)) {\n    return new HtmlResponseError(apiResponse);\n  }\n\n  return isValid;\n};\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,oBAAb,cAAuC,SAAS;CAC9C,YAAY,KAAkB;EAC5B,MAAM,GAAG;EACT,KAAK,UAAU;CACjB;AACF;AAEA,MAAa,uBAAuB,UAClC,iBAAiB;;;;;;;;;;ACbnB,MAAa,4BAA8C,gBAAgB;CACzE,MAAM,UAAU,sBAAsB,WAAW;CAEjD,IAAI,WAAW,eAAe,WAAW,GACvC,OAAO,IAAI,kBAAkB,WAAW;CAG1C,OAAO;AACT"}
+{"version":3,"file":"validateConnectionStatus-olE2sQ3U.js","names":[],"sources":["../src/errors/HtmlResponseError.ts","../src/clients/validateConnectionStatus.ts"],"sourcesContent":["import type { ApiResponse } from '../fetchClient/createFetchClient/types';\n\nimport { ApiError } from './ApiError';\n\n/**\n * A successful response that carried an HTML page instead of the endpoint's payload.\n *\n * - Connection answers an expired session with a 302 to the login screen, and `fetch` follows it,\n *   so the request resolves `200 text/html`.\n * - Without this the page reaches the caller as a string typed as the endpoint's DTO and fails much\n *   later, wherever the value is first read — an Immutable accessor on a string, modules away.\n * - The message stays constant so Sentry groups every occurrence together; `request` and `response`\n *   carry the per-request detail.\n * - Raised only by the clients that opt in: some APIs do serve HTML from a 200 on purpose.\n */\nexport class HtmlResponseError extends ApiError {\n  constructor(res: ApiResponse) {\n    super(res);\n    this.message = 'Expected data, got an HTML page. The session has most likely expired.';\n  }\n}\n\nexport const isHtmlResponseError = (error: unknown): error is HtmlResponseError =>\n  error instanceof HtmlResponseError;\n","import { HtmlResponseError } from '../errors';\nimport { defaultValidateStatus, type ValidateStatusFn } from '../fetchClient';\n\nimport { isLoginPageRedirect } from './isLoginPageRedirect';\n\n/**\n * Status validation for the APIs Connection serves off its own host — storage and auth.\n *\n * - Rejects a successful login page; `HtmlResponseError` says why.\n * - HTML on a *failed* response is a real error page and stays an `ApiError`.\n * - Management answers the same condition with its own session-expiry error instead.\n */\nexport const validateConnectionStatus: ValidateStatusFn = (apiResponse) => {\n  const isValid = defaultValidateStatus(apiResponse);\n\n  if (isValid && isLoginPageRedirect(apiResponse)) {\n    return new HtmlResponseError(apiResponse);\n  }\n\n  return isValid;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,oBAAb,cAAuC,SAAS;CAC9C,YAAY,KAAkB;EAC5B,MAAM,GAAG;EACT,KAAK,UAAU;CACjB;AACF;AAEA,MAAa,uBAAuB,UAClC,iBAAiB;;;;;;;;;;ACXnB,MAAa,4BAA8C,gBAAgB;CACzE,MAAM,UAAU,sBAAsB,WAAW;CAEjD,IAAI,WAAW,oBAAoB,WAAW,GAC5C,OAAO,IAAI,kBAAkB,WAAW;CAG1C,OAAO;AACT"}

package/dist/vault/index.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_UserError = require("../UserError-CSGO1qII.cjs");
-require("../createFetchClient-BRfTjBLV.cjs");
-const require_createGenericFetchClient = require("../createGenericFetchClient-DHs-i7_O.cjs");
-const require_createOpenapiFetchClient = require("../createOpenapiFetchClient-CyDUFxHB.cjs");
-const require_auth = require("../auth-DP-6TFiM.cjs");
+require("../createFetchClient-DgMiqTJ8.cjs");
+const require_createGenericFetchClient = require("../createGenericFetchClient-o3cPJeRn.cjs");
+const require_createOpenapiFetchClient = require("../createOpenapiFetchClient-DhUU3M1W.cjs");
+const require_auth = require("../auth-JQ33o3nU.cjs");
 //#region src/clients/vault/vaultClient.ts
 const createVaultClient = ({ baseUrl, middlewares, auth }) => {
 	const client = require_createOpenapiFetchClient.createOpenapiFetchClient({

package/dist/vault/index.d.cts

@@ -1,2 +1,2 @@
-import { t as createVaultClient } from "../index-C7e3wBt9.cjs";
+import { t as createVaultClient } from "../index-Dx52hNLP.cjs";
 export { createVaultClient };

package/dist/vault/index.d.ts

@@ -1,2 +1,2 @@
-import { t as createVaultClient } from "../index-Bc_hXWae.js";
+import { t as createVaultClient } from "../index-BuegqrS1.js";
 export { createVaultClient };

package/dist/vault/index.js

@@ -1,8 +1,8 @@
 import { t as UserError } from "../UserError-By_Zckmc.js";
-import "../createFetchClient-BbG46bL0.js";
-import { t as createGenericFetchClient } from "../createGenericFetchClient-BHYQLZhe.js";
-import { t as createOpenapiFetchClient } from "../createOpenapiFetchClient-Bn6_Pn0H.js";
-import { t as createAuthHeaders } from "../auth-DtbQaeDj.js";
+import "../createFetchClient-U-ZrwPl2.js";
+import { t as createGenericFetchClient } from "../createGenericFetchClient-rxvUUbap.js";
+import { t as createOpenapiFetchClient } from "../createOpenapiFetchClient-BVSc9ibR.js";
+import { t as createAuthHeaders } from "../auth-aItmDu45.js";
 //#region src/clients/vault/vaultClient.ts
 const createVaultClient = ({ baseUrl, middlewares, auth }) => {
 	const client = createOpenapiFetchClient({

package/dist/vault/types.d.cts

@@ -1,2 +1,2 @@
-import { a as GetVariablesQuery, i as GetVariablesByBranchId, n as CreateVariableBody, o as VariableWithHash, r as DeleteVariablePath, t as AnyVariable } from "../types-CJHi0zdD.cjs";
+import { a as GetVariablesQuery, i as GetVariablesByBranchId, n as CreateVariableBody, o as VariableWithHash, r as DeleteVariablePath, t as AnyVariable } from "../types-M46WuBSm.cjs";
 export { AnyVariable, CreateVariableBody, DeleteVariablePath, GetVariablesByBranchId, GetVariablesQuery, VariableWithHash };

package/dist/vault/types.d.ts

@@ -1,2 +1,2 @@
-import { a as GetVariablesQuery, i as GetVariablesByBranchId, n as CreateVariableBody, o as VariableWithHash, r as DeleteVariablePath, t as AnyVariable } from "../types-D-qI9ne4.js";
+import { a as GetVariablesQuery, i as GetVariablesByBranchId, n as CreateVariableBody, o as VariableWithHash, r as DeleteVariablePath, t as AnyVariable } from "../types-l9o4gFsI.js";
 export { AnyVariable, CreateVariableBody, DeleteVariablePath, GetVariablesByBranchId, GetVariablesQuery, VariableWithHash };