@keboola/api-client 41.0.0 → 43.0.0

package/dist/{types-DE9hgr7i.d.cts → types-CgBzm1YR.d.cts}

@@ -62,6 +62,32 @@ type paths = {
     patch?: never;
     trace?: never;
   };
+  '/schedules/migrate': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Activate Schedule With A Reused Token
+     * @description Activates a configuration of `keboola.scheduler` so that it becomes an active schedule, reusing the Storage token of an already activated schedule instead of creating a new one.
+     *
+     *     Restricted to migrating a schedule from `keboola.orchestrator` to `keboola.flow`: the source schedule must target `keboola.orchestrator` and the activated configuration must target `keboola.flow`, otherwise the request is rejected with `400`. No Storage token is created, so the caller does not have to be allowed to create tokens - and because this endpoint accepts a role-less token where `POST /schedules` does not, the allowed component pair is deliberately narrow. The token is shared, not moved - the source schedule keeps running under it, and the token is dropped only once the last schedule using it is deleted.
+     *
+     *     If there already is a schedule for the given `configurationId`, it is updated and `sourceConfigurationId` is ignored, so repeated calls stay idempotent.
+     *
+     *     Unlike `POST /schedules`, this endpoint also accepts a role-less (machine-minted) project token, because it mints no token of its own. Everything else about the authorization is the same.
+     */
+    post: operations['migrateSchedule'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   '/schedules/{scheduleId}': {
     parameters: {
       query?: never;
@@ -160,6 +186,38 @@ type components = {
         timezone: string;
         /** @enum {string} */
         state: 'enabled' | 'disabled';
+        /**
+         * Format: date-time
+         * @description ISO-8601 timestamp of the next firing, evaluated in the schedule's timezone.
+         *     Null when the schedule is not enabled or the expression can not be evaluated.
+         *     Reflects the schedule's own state only: a schedule pointing at a disabled target
+         *     configuration still reports its next fire time even though the run would be skipped.
+         * @example 2021-03-13T06:30:00+00:00
+         */
+        nextRunAt: string | null;
+        /**
+         * @description The next four firings, same semantics as nextRunAt (which is the first element).
+         *     Empty when the schedule is not enabled or the expression can not be evaluated.
+         * @example [
+         *       "2021-03-13T06:30:00+00:00",
+         *       "2021-03-14T06:30:00+00:00",
+         *       "2021-03-15T06:30:00+00:00",
+         *       "2021-03-16T06:30:00+00:00"
+         *     ]
+         */
+        nextRunsAt: string[];
+        /**
+         * @description Human-readable prose describing the cron expression, with the timezone appended.
+         *     Falls back to the raw cron expression when it can not be parsed.
+         * @example Every 2 minutes (UTC)
+         */
+        humanCron: string;
+        /**
+         * @description Coarse grouping of the schedule cadence for display purposes.
+         * @example custom
+         * @enum {string}
+         */
+        periodLabel: 'daily' | 'weekly' | 'monthly' | 'custom';
       };
       target: {
         /** @example keboola.ex-db-snowflake */
@@ -237,6 +295,53 @@ interface operations {
       };
     };
   };
+  migrateSchedule: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: {
+      content: {
+        'application/json': {
+          /** @description Id of the `keboola.scheduler` configuration to activate. */
+          configurationId: string;
+          /** @description Id of the `keboola.scheduler` configuration whose schedule owns the Storage token the new schedule will run under. That configuration must already have a schedule in the same project as the caller's token - it is the schedule row that is looked up, so a configuration that was never activated is rejected - and that schedule must target `keboola.orchestrator`. Its state does not matter: a disabled schedule still owns a usable token. */
+          sourceConfigurationId: string;
+        };
+      };
+    };
+    responses: {
+      /** @description Schedule Activated */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Schedule'];
+        };
+      };
+      /** @description There is no schedule for the given `sourceConfigurationId` in this project, or the component pair is not `keboola.orchestrator` to `keboola.flow` */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Error'];
+        };
+      };
+      /** @description Error response */
+      default: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Error'];
+        };
+      };
+    };
+  };
   getSchedule: {
     parameters: {
       query?: never;
@@ -370,4 +475,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-DE9hgr7i.d.cts.map
+//# sourceMappingURL=types-CgBzm1YR.d.cts.map

package/dist/{types-FwRmjsNN.d.ts → types-CigD_EF5.d.ts}

@@ -1,8 +1,8 @@
-import { i as CreateMetaObjectInput } from "./types-B_iLJlp4.js";
-import { n as createMetastoreClient } from "./index-BDZvaRud.js";
+import { i as CreateMetaObjectInput } from "./types-CwZgZqrA.js";
+import { n as createMetastoreClient } from "./index-B72LTF-k.js";
 //#region src/sdks/semanticLayer/vocabulary.d.ts
 /**
- * The closed value sets the metastore accepts inside a semantic object's `data`.
+ * The closed value sets the metastore accepts on a semantic object.
  *
  * - The single runtime source for the unions `./types` derives from these arrays.
  * - Imports nothing: `./types` reads it, never the reverse.
@@ -22,6 +22,8 @@ declare const CONSTRAINT_SEVERITIES: readonly ['error', 'warning', 'info'];
 declare const CONSTRAINT_SCOPES: readonly ['global', 'per_location', 'per_date', 'per_category'];
 declare const RULE_OPERATORS: readonly ['<', '<=', '=', '>=', '>', '!=', 'between', 'in', 'sum_equals', 'ratio_between'];
 declare const RELATIONSHIP_JOIN_TYPES: readonly ['left', 'inner'];
+/** Who can read an object, narrowest first; an envelope `meta` field, not part of `data`. */
+declare const SEMANTIC_OBJECT_SCOPES: readonly ['project', 'targeted', 'organization'];
 //#endregion
 //#region src/sdks/semanticLayer/types.d.ts
 type MetastoreClient = ReturnType<typeof createMetastoreClient>;
@@ -133,16 +135,24 @@ type SemanticChildObjectDataMap = {
 };
 type SemanticChildObjectType = keyof SemanticChildObjectDataMap;
 type SemanticObjectType = SemanticChildObjectType | 'semantic-model';
+type SemanticObjectScope = (typeof SEMANTIC_OBJECT_SCOPES)[number];
 type SemanticObjectMeta = {
   name?: string;
   branch?: string;
-  projectId?: number;
+  projectId?: number | null;
   organizationId?: string;
   revision?: number;
   schemaVersion?: string;
   createdAt?: string;
   lastUpdated?: string;
   revisionCreatedAt?: string;
+  scope?: SemanticObjectScope;
+  sourceProjectId?: number;
+  /** The projects a `targeted` object is shared with, read-only. */
+  targetProjectIds?: number[];
+  /** Set while a `project`-scope object awaits an org-admin decision. Cleared by promoting
+   *  (PATCH `{scope:"organization"}`) or withdrawing the request. */
+  scopeElevationRequestedAt?: string;
 };
 /**
  * Normalized metastore object as returned by this SDK. Matches the live metastore
@@ -171,6 +181,8 @@ type SemanticModelChildRef = {
   objectType: SemanticChildObjectType;
   objectUUID: string;
   name: string | undefined;
+  /** What sibling objects point at it by: a dataset's `tableId`, a metric's `name`; else absent. */
+  referenceKey?: string;
 };
 /**
  * An object a read could not parse, as far as the raw envelope can be trusted to say.
@@ -190,5 +202,5 @@ 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-FwRmjsNN.d.ts.map
+export { CONSTRAINT_SEVERITIES as A, SemanticRelationshipJoinType as C, SemanticValidationQuery as D, SemanticUnreadableObjectRef as E, SEMANTIC_OBJECT_SCOPES as F, SQL_DIALECTS as I, FIELD_ROLES as M, RELATIONSHIP_JOIN_TYPES as N, UpdateSemanticObjectMeta as O, RULE_OPERATORS as P, SemanticRelationshipData as S, SemanticRuleOperator as T, SemanticModelData as _, SemanticChildObjectType as a, SemanticObjectScope as b, SemanticConstraintSeverity as c, SemanticFieldData as d, SemanticFieldRole as f, SemanticModelChildRef as g, SemanticModelChildDeleteFailure as h, SemanticChildObjectDataMap as i, CONSTRAINT_TYPES as j, CONSTRAINT_SCOPES 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, SemanticRuleExpression as w, SemanticObjectType as x, SemanticObjectMeta as y };
+//# sourceMappingURL=types-CigD_EF5.d.ts.map

package/dist/{types-B_iLJlp4.d.ts → types-CwZgZqrA.d.ts}

@@ -1663,7 +1663,12 @@ type components = {
 };
 //#endregion
 //#region src/clients/metastore/repository/types.d.ts
-type MetaObjectMeta = NonNullable<components['schemas']['handlers.JSONAPIMetaObjectResource']['meta']>;
+type MetaObjectScope = 'project' | 'organization' | 'targeted';
+type MetaObjectMeta = Omit<NonNullable<components['schemas']['handlers.JSONAPIMetaObjectResource']['meta']>, 'projectId' | 'scope'> & {
+  targetProjectIds?: number[];
+  projectId?: number | null;
+  scope?: MetaObjectScope;
+};
 type MetaObject<TData extends Record<string, unknown>, TDataOptional extends boolean = false> = {
   uuid: string;
   meta: MetaObjectMeta;
@@ -1675,14 +1680,30 @@ type MetaObject<TData extends Record<string, unknown>, TDataOptional extends boo
 type GetMetaObjectsPath = OpenapiPathType<paths['/api/v1/repository/{objectType}']['get']>;
 type GetMetaObjectsSchemaQuery = OpenapiQueryType<paths['/api/v1/repository/{objectType}']['get']>;
 type GetMetaObjectsQuery = GetMetaObjectsSchemaQuery & Record<string, string | number | boolean>;
+/**
+ * `GetMetaObjectsPath` plus the dynamic-filter `query` hybrid, plus the server-side filters this
+ * list endpoint supports beyond what the generated query type expresses (`limit`/`offset` only —
+ * swaggo can't declare a dynamic per-field query key in its annotations).
+ */
 type GetMetaObjectsInput = GetMetaObjectsPath & {
   query?: GetMetaObjectsQuery;
+  /** Every child object schema declares this `x-filterable: true` server-side. Passed as a real
+   * query filter instead of fetching the whole type's list and filtering client-side. */
+  modelUUID?: string;
+  /** Filters to project-scope objects with a pending request. Backs "my pending requests" for
+   * the requester, on the regular per-project list — the org-wide queue filters `/organization`. */
+  pendingElevationOnly?: boolean;
+  /** Opt-in: sorts `scope[order]=asc` (organization, targeted, project). Off by default —
+   * `getMetaObjects` backs every object-type SDK, not just semantic-layer's. */
+  sortByScope?: boolean;
 };
 type CreateMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}']['post']>;
 type CreateMetaObjectBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}']['post']>;
 type CreateMetaObjectReturn = OpenapiReturnType<paths['/api/v1/repository/{objectType}']['post']>;
-type CreateMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = CreateMetaObjectPath & Omit<CreateMetaObjectBody, 'data'> & {
+type CreateMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = CreateMetaObjectPath & Omit<CreateMetaObjectBody, 'data' | 'scope'> & {
   data: TData;
+  scope?: MetaObjectScope;
+  dropSourceProject?: boolean;
 };
 type GetMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['get']>;
 type DeleteMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['delete']>;
@@ -1703,9 +1724,10 @@ type UpdateMetaObjectContentPatch<TData extends Record<string, unknown>> = {
   scope?: never;
 };
 type UpdateMetaObjectScopeStepUp = {
-  scope: NonNullable<UpdateMetaObjectBody['scope']>;
+  scope: 'organization';
   data?: never;
   name?: never;
+  dropSourceProject?: boolean;
 };
 /**
  * A PATCH is exactly one of two operations, and the metastore enforces the split server-side: a
@@ -1719,6 +1741,10 @@ type UpdateMetaObjectInput<TData extends Record<string, unknown> = Record<string
 type ReplaceTargetProjectsPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}/target-projects']['put']>;
 type ReplaceTargetProjectsBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}/{UUID}/target-projects']['put']>;
 type ReplaceTargetProjectsInput = ReplaceTargetProjectsPath & ReplaceTargetProjectsBody;
+type ScopeElevationRequestPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}/scope-elevation-request']['put']>;
+type GetOrganizationMetaObjectsPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/organization']['get']>;
+type GetOrganizationMetaObjectsSchemaQuery = OpenapiQueryType<paths['/api/v1/repository/{objectType}/organization']['get']>;
+type GetOrganizationMetaObjectsQuery = GetOrganizationMetaObjectsSchemaQuery & Record<string, string | number | boolean>;
 type ReplaceMetaObjectPath = OpenapiPathType<paths['/api/v1/repository/{objectType}/{UUID}']['put']>;
 type ReplaceMetaObjectBody = OpenapiBodyType<paths['/api/v1/repository/{objectType}/{UUID}']['put']>;
 type ReplaceMetaObjectInput<TData extends Record<string, unknown> = Record<string, unknown>> = ReplaceMetaObjectPath & Omit<ReplaceMetaObjectBody, 'data'> & {
@@ -1749,5 +1775,5 @@ type MetaStoreListResponse<TData extends Record<string, unknown>> = {
 type GetSchemaPath = OpenapiPathType<paths['/api/v1/schema/{objectType}']['get']>;
 type GetVersionedSchemaPath = OpenapiPathType<paths['/api/v1/schema/{objectType}/{version}']['get']>;
 //#endregion
-export { UpdateMetaObjectBody as A, RawMetaObject as C, ReplaceTargetProjectsBody as D, ReplaceMetaObjectPath as E, UpdateMetaObjectPath as M, components as N, ReplaceTargetProjectsInput as O, paths as P, MetaStoreObjectResponse as S, ReplaceMetaObjectInput as T, GetMetaObjectsQuery as _, CreateMetaObjectPath as a, MetaObjectMeta as b, DeleteMetaObjectRevisionPath as c, GetMetaObjectRevisionsInput as d, GetMetaObjectRevisionsPath as f, GetMetaObjectsPath as g, GetMetaObjectsInput as h, CreateMetaObjectInput as i, UpdateMetaObjectInput as j, ReplaceTargetProjectsPath as k, GetMetaObjectPath as l, GetMetaObjectRevisionsSchemaQuery as m, GetVersionedSchemaPath as n, CreateMetaObjectReturn as o, GetMetaObjectRevisionsQuery as p, CreateMetaObjectBody as r, DeleteMetaObjectPath as s, GetSchemaPath as t, GetMetaObjectRevisionPath as u, GetMetaObjectsSchemaQuery as v, ReplaceMetaObjectBody as w, MetaStoreListResponse as x, MetaObject as y };
-//# sourceMappingURL=types-B_iLJlp4.d.ts.map
+export { ReplaceMetaObjectPath as A, MetaObjectMeta as C, RawMetaObject as D, MetaStoreObjectResponse as E, UpdateMetaObjectBody as F, UpdateMetaObjectInput as I, UpdateMetaObjectPath as L, ReplaceTargetProjectsInput as M, ReplaceTargetProjectsPath as N, ReplaceMetaObjectBody as O, ScopeElevationRequestPath as P, components as R, MetaObject as S, MetaStoreListResponse as T, GetMetaObjectsQuery as _, CreateMetaObjectPath as a, GetOrganizationMetaObjectsQuery as b, DeleteMetaObjectRevisionPath as c, GetMetaObjectRevisionsInput as d, GetMetaObjectRevisionsPath as f, GetMetaObjectsPath as g, GetMetaObjectsInput as h, CreateMetaObjectInput as i, ReplaceTargetProjectsBody as j, ReplaceMetaObjectInput as k, GetMetaObjectPath as l, GetMetaObjectRevisionsSchemaQuery as m, GetVersionedSchemaPath as n, CreateMetaObjectReturn as o, GetMetaObjectRevisionsQuery as p, CreateMetaObjectBody as r, DeleteMetaObjectPath as s, GetSchemaPath as t, GetMetaObjectRevisionPath as u, GetMetaObjectsSchemaQuery as v, MetaObjectScope as w, GetOrganizationMetaObjectsSchemaQuery as x, GetOrganizationMetaObjectsPath as y, paths as z };
+//# sourceMappingURL=types-CwZgZqrA.d.ts.map

package/dist/{types-B61aCifg.d.cts → types-D9axmt5o.d.cts}

@@ -150,6 +150,9 @@ type components = {
        *
        *     Attributes are part of the variable identity, so two variables with the same key but different attributes
        *     are considered different.
+       *
+       *     The attribute names `key` and `projectId` are reserved and are rejected with a 422 when creating a
+       *     variable. Existing variables that already contain such attributes are still returned unchanged.
        * @default {}
        */
       attributes: {
@@ -383,4 +386,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-B61aCifg.d.cts.map
+//# sourceMappingURL=types-D9axmt5o.d.cts.map

package/dist/{types-CWyXTMwy.d.ts → types-DaMmgW-O.d.ts}

@@ -62,6 +62,32 @@ type paths = {
     patch?: never;
     trace?: never;
   };
+  '/schedules/migrate': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Activate Schedule With A Reused Token
+     * @description Activates a configuration of `keboola.scheduler` so that it becomes an active schedule, reusing the Storage token of an already activated schedule instead of creating a new one.
+     *
+     *     Restricted to migrating a schedule from `keboola.orchestrator` to `keboola.flow`: the source schedule must target `keboola.orchestrator` and the activated configuration must target `keboola.flow`, otherwise the request is rejected with `400`. No Storage token is created, so the caller does not have to be allowed to create tokens - and because this endpoint accepts a role-less token where `POST /schedules` does not, the allowed component pair is deliberately narrow. The token is shared, not moved - the source schedule keeps running under it, and the token is dropped only once the last schedule using it is deleted.
+     *
+     *     If there already is a schedule for the given `configurationId`, it is updated and `sourceConfigurationId` is ignored, so repeated calls stay idempotent.
+     *
+     *     Unlike `POST /schedules`, this endpoint also accepts a role-less (machine-minted) project token, because it mints no token of its own. Everything else about the authorization is the same.
+     */
+    post: operations['migrateSchedule'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   '/schedules/{scheduleId}': {
     parameters: {
       query?: never;
@@ -160,6 +186,38 @@ type components = {
         timezone: string;
         /** @enum {string} */
         state: 'enabled' | 'disabled';
+        /**
+         * Format: date-time
+         * @description ISO-8601 timestamp of the next firing, evaluated in the schedule's timezone.
+         *     Null when the schedule is not enabled or the expression can not be evaluated.
+         *     Reflects the schedule's own state only: a schedule pointing at a disabled target
+         *     configuration still reports its next fire time even though the run would be skipped.
+         * @example 2021-03-13T06:30:00+00:00
+         */
+        nextRunAt: string | null;
+        /**
+         * @description The next four firings, same semantics as nextRunAt (which is the first element).
+         *     Empty when the schedule is not enabled or the expression can not be evaluated.
+         * @example [
+         *       "2021-03-13T06:30:00+00:00",
+         *       "2021-03-14T06:30:00+00:00",
+         *       "2021-03-15T06:30:00+00:00",
+         *       "2021-03-16T06:30:00+00:00"
+         *     ]
+         */
+        nextRunsAt: string[];
+        /**
+         * @description Human-readable prose describing the cron expression, with the timezone appended.
+         *     Falls back to the raw cron expression when it can not be parsed.
+         * @example Every 2 minutes (UTC)
+         */
+        humanCron: string;
+        /**
+         * @description Coarse grouping of the schedule cadence for display purposes.
+         * @example custom
+         * @enum {string}
+         */
+        periodLabel: 'daily' | 'weekly' | 'monthly' | 'custom';
       };
       target: {
         /** @example keboola.ex-db-snowflake */
@@ -237,6 +295,53 @@ interface operations {
       };
     };
   };
+  migrateSchedule: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: {
+      content: {
+        'application/json': {
+          /** @description Id of the `keboola.scheduler` configuration to activate. */
+          configurationId: string;
+          /** @description Id of the `keboola.scheduler` configuration whose schedule owns the Storage token the new schedule will run under. That configuration must already have a schedule in the same project as the caller's token - it is the schedule row that is looked up, so a configuration that was never activated is rejected - and that schedule must target `keboola.orchestrator`. Its state does not matter: a disabled schedule still owns a usable token. */
+          sourceConfigurationId: string;
+        };
+      };
+    };
+    responses: {
+      /** @description Schedule Activated */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Schedule'];
+        };
+      };
+      /** @description There is no schedule for the given `sourceConfigurationId` in this project, or the component pair is not `keboola.orchestrator` to `keboola.flow` */
+      400: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Error'];
+        };
+      };
+      /** @description Error response */
+      default: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': components['schemas']['Error'];
+        };
+      };
+    };
+  };
   getSchedule: {
     parameters: {
       query?: never;
@@ -370,4 +475,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-CWyXTMwy.d.ts.map
+//# sourceMappingURL=types-DaMmgW-O.d.ts.map