@confighub/api 0.10.1 → 0.10.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.cts +1223 -467
  2. package/dist/index.d.ts +1223 -467
  3. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -2593,6 +2593,26 @@ interface paths {
2593
2593
  patch: operations["PatchUnit"];
2594
2594
  trace?: never;
2595
2595
  };
2596
+ "/space/{space_id}/unit/{unit_id}/blame": {
2597
+ parameters: {
2598
+ query?: never;
2599
+ header?: never;
2600
+ path?: never;
2601
+ cookie?: never;
2602
+ };
2603
+ /**
2604
+ * Get what set each field of a Unit
2605
+ * @description Returns, for every field of a Unit's configuration, what set the value that is there -- the change, who made it, when and why -- following each merge and Link resolve upstream to where the value was set, and everything else recorded about the field: whether it is protected or guarded, the conflicts and Link findings about it, the failed validation checks that name it, and whether a NeedsProvides Link needs or provides it. A field the Unit does not have is listed, with Absent, when a conflict names it.
2606
+ */
2607
+ get: operations["GetUnitBlame"];
2608
+ put?: never;
2609
+ post?: never;
2610
+ delete?: never;
2611
+ options?: never;
2612
+ head?: never;
2613
+ patch?: never;
2614
+ trace?: never;
2615
+ };
2596
2616
  "/space/{space_id}/unit/{unit_id}/conflicts": {
2597
2617
  parameters: {
2598
2618
  query?: never;
@@ -2737,6 +2757,26 @@ interface paths {
2737
2757
  patch?: never;
2738
2758
  trace?: never;
2739
2759
  };
2760
+ "/space/{space_id}/unit/{unit_id}/path": {
2761
+ parameters: {
2762
+ query?: never;
2763
+ header?: never;
2764
+ path?: never;
2765
+ cookie?: never;
2766
+ };
2767
+ /**
2768
+ * Get everything recorded about one field of a Unit
2769
+ * @description Returns everything recorded about one field of a Unit's configuration: the field as the Unit's blame reports it, its own annotations, whether the Unit's last Release includes its value, and each change from this Unit out to where the value was set with the Mutation and Revision it was read from. With history, it also returns every change the Unit recorded to the field. A field that names nothing is a 404; one that names several fields, or a value holding several, is a 400 whose message lists them.
2770
+ */
2771
+ get: operations["GetUnitPath"];
2772
+ put?: never;
2773
+ post?: never;
2774
+ delete?: never;
2775
+ options?: never;
2776
+ head?: never;
2777
+ patch?: never;
2778
+ trace?: never;
2779
+ };
2740
2780
  "/space/{space_id}/unit/{unit_id}/protection": {
2741
2781
  parameters: {
2742
2782
  query?: never;
@@ -3281,6 +3321,26 @@ interface paths {
3281
3321
  patch?: never;
3282
3322
  trace?: never;
3283
3323
  };
3324
+ "/unit_blame": {
3325
+ parameters: {
3326
+ query?: never;
3327
+ header?: never;
3328
+ path?: never;
3329
+ cookie?: never;
3330
+ };
3331
+ /**
3332
+ * Get what set each field of many Units across spaces
3333
+ * @description Returns the blame of every Unit the where clause selects, across every Space in the organization, a page of Units at a time. This is the bulk counterpart of the single-Unit blame subresource. Scope it to one Space with a where clause for a variant, or to several for several variants: a field has the same REF in every variant of a Unit. A Unit whose blame cannot be read carries an Error and no fields.
3334
+ */
3335
+ get: operations["SearchUnitBlame"];
3336
+ put?: never;
3337
+ post?: never;
3338
+ delete?: never;
3339
+ options?: never;
3340
+ head?: never;
3341
+ patch?: never;
3342
+ trace?: never;
3343
+ };
3284
3344
  "/unit_data": {
3285
3345
  parameters: {
3286
3346
  query?: never;
@@ -4003,6 +4063,234 @@ interface components {
4003
4063
  ProvidedResource?: components["schemas"]["ResourceInfo"];
4004
4064
  };
4005
4065
  BindingList: components["schemas"]["Binding"][];
4066
+ BlameField: {
4067
+ /** @description True for a field the unit does not have, listed because a conflict names it: a merge could not find the path, or the resource, to make an upstream change to. It has no value and no history. */
4068
+ Absent?: boolean;
4069
+ /** @description The changes that put the value here, from this unit out to where it was set, following each merge and Link resolve upstream. The last is the answer. */
4070
+ Chain?: components["schemas"]["BlameOrigin"][];
4071
+ /** @description The unit's outstanding conflicts about the field: upstream changes to it a merge or resolve dropped. */
4072
+ Conflicts?: components["schemas"]["MutationConflict"][];
4073
+ /** @description The unit's Link findings about the field: what a Link's resolve could not do here. */
4074
+ Findings?: components["schemas"]["LinkFinding"][];
4075
+ /** @description What there is to know about the field, one code each: Protected, Guarded, Conflict, Absent, Finding, ValidationError, ValidationWarning, Upgraded, SetByLink, SetByTrigger, ChangeOrder, Unreleased, Needed and Provided. */
4076
+ Flags?: string[];
4077
+ /** @description The guards on the field: its own, its ancestors' and its resource's, which an operation writing here has to be cleared for. */
4078
+ Guards?: {
4079
+ [key: string]: string;
4080
+ };
4081
+ /** @description The unit's needed paths that are the field: a value it is to take from an upstream unit through a NeedsProvides Link. */
4082
+ Needed?: components["schemas"]["BlameNeededPath"][];
4083
+ /** @description The field's path, in the syntax functions and Links take. */
4084
+ Path?: string;
4085
+ /** @description True for a local override, which a merge from upstream leaves alone. */
4086
+ Protected?: boolean;
4087
+ /** @description The unit's provided paths that are the field: a value it offers downstream units through NeedsProvides Links. */
4088
+ Provided?: components["schemas"]["AttributeInfo"][];
4089
+ /** @description The field's short reference: the same in every Revision of the unit and in every variant of it, so it lines up one field across variants. The path report takes it, or a prefix of it, in place of the resource and path. */
4090
+ Ref?: string;
4091
+ /** @description The name of the resource the field is in. */
4092
+ ResourceName?: string;
4093
+ /** @description The name of the resource without its scope, such as its namespace, which is how a resource a variant renamed is matched. */
4094
+ ResourceNameWithoutScope?: string;
4095
+ /** @description True when the field is protected because its resource is protected as a whole. */
4096
+ ResourceProtected?: boolean;
4097
+ /** @description The type of the resource the field is in. */
4098
+ ResourceType?: string;
4099
+ /**
4100
+ * Format: uuid
4101
+ * @description The Space of the unit the field is in.
4102
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4103
+ */
4104
+ SpaceID?: string;
4105
+ /** @description The slug of the Space of the unit the field is in. */
4106
+ SpaceSlug?: string;
4107
+ /**
4108
+ * Format: uuid
4109
+ * @description The unit the field is in.
4110
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4111
+ */
4112
+ UnitID?: string;
4113
+ /** @description The slug of the unit the field is in. */
4114
+ UnitSlug?: string;
4115
+ /** @description The unit's failed validating checks that name the field. */
4116
+ Validation?: components["schemas"]["BlameValidation"][];
4117
+ /** @description The field's value, as YAML. */
4118
+ Value?: string;
4119
+ };
4120
+ BlameNeededPath: {
4121
+ /** @description Name of the registered attribute */
4122
+ AttributeName?: string;
4123
+ BoundLink?: string;
4124
+ /** @description Line comment on the attribute at the specified Path */
4125
+ Comment?: string;
4126
+ /** @description Data type if the attribute value. */
4127
+ DataType?: string;
4128
+ /** @description Additional attribute details */
4129
+ Details?: components["schemas"]["AttributeDetails"];
4130
+ /** @description Name of the function invocation corresponding to the output */
4131
+ FunctionName?: string;
4132
+ /** @description Index of the function invocation corresponding to the output. Useful in the case that multiple function invocations in the same executor call return AttributeValueList output. */
4133
+ Index?: number;
4134
+ /** @description Issues found with the attribute */
4135
+ Issues?: components["schemas"]["Issue"][];
4136
+ /** @description Path of the attribute */
4137
+ Path?: string;
4138
+ /** @description Category of configuration element represented in the configuration data; Kubernetes resources are of category Resource, and application configuration files are of category AppConfig */
4139
+ ResourceCategory?: string;
4140
+ /** @description Name of a resource in the system under management represented in the configuration data; Kubernetes resources are represented in the form <metadata.namespace>/<metadata.name>; not all ToolchainTypes necessarily use '/' as a separator between any scope(s) and name or other client-chosen ID */
4141
+ ResourceName?: string;
4142
+ /** @description Name of a resource in the system under management represented in the configuration data with generated prefixes and suffixes stripped; empty if nothing to strip */
4143
+ ResourceNameStableCore?: string;
4144
+ /** @description Name of a resource in the system under management represented in the configuration data, without any uniquifying scope, such as Namespace, Project, Account, Region, etc.; Kubernetes resources are represented in the form <metadata.name> */
4145
+ ResourceNameWithoutScope?: string;
4146
+ /** @description Type of a resource in the system under management represented in the configuration data; Kubernetes resources are represented in the form <apiVersion>/<kind> (aka group-version-kind) */
4147
+ ResourceType?: string;
4148
+ /** @description Score of finding attributed to this Path */
4149
+ Score?: string;
4150
+ /** @description Value of the attribute at the specified Path */
4151
+ Value?: unknown;
4152
+ };
4153
+ BlameOrigin: {
4154
+ /** @description The ChangeOrders that made the Revision. */
4155
+ ChangeOrderIDs?: components["schemas"]["UUID"][];
4156
+ /** @description The slugs of the ChangeOrders that made the Revision. */
4157
+ ChangeOrders?: string[];
4158
+ /** @description The Revision's change description. */
4159
+ Description?: string;
4160
+ /** @description The function the change ran, if it ran one. */
4161
+ Function?: string;
4162
+ /** @description The slug of the Invocation the change ran. */
4163
+ Invocation?: string;
4164
+ /**
4165
+ * Format: uuid
4166
+ * @description The Invocation the change ran, if it ran one.
4167
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4168
+ */
4169
+ InvocationID?: string;
4170
+ /** @description The slug of the Link that made the change. */
4171
+ Link?: string;
4172
+ /**
4173
+ * Format: uuid
4174
+ * @description The Link that made the change, if one did.
4175
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4176
+ */
4177
+ LinkID?: string;
4178
+ /** @description The unit a Link's resolve read the value from, as space/unit or unit. */
4179
+ LinkUpstream?: string;
4180
+ /**
4181
+ * Format: int64
4182
+ * @description The number of the Revision of the upstream unit the Link's resolve read.
4183
+ */
4184
+ LinkUpstreamRevisionNum?: number;
4185
+ /**
4186
+ * Format: uuid
4187
+ * @description The unit a Link's resolve read the value from, whether or not the chain could follow it there.
4188
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4189
+ */
4190
+ LinkUpstreamUnitID?: string;
4191
+ /**
4192
+ * Format: int64
4193
+ * @description The number of the Mutation that recorded the change; 0 for a change no Mutation recorded.
4194
+ */
4195
+ MutationNum?: number;
4196
+ /** @description The Releases that bundle the Revision. */
4197
+ ReleaseIDs?: components["schemas"]["UUID"][];
4198
+ /** @description The numbers of the Releases that bundle the Revision. */
4199
+ Releases?: string[];
4200
+ /**
4201
+ * Format: uuid
4202
+ * @description The Revision the change made.
4203
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4204
+ */
4205
+ RevisionID?: string;
4206
+ /**
4207
+ * Format: int64
4208
+ * @description The number of the Revision the change made.
4209
+ */
4210
+ RevisionNum?: number;
4211
+ /** @description What decided to make the change, most specific first: the Link or Trigger, the function, the external source, the Invocation, the merge, or otherwise the operation that made the Revision. For people to read; the fields beside it say the same for programs. */
4212
+ SetBy?: string;
4213
+ /** @description The operation that made the Revision, such as UpdateUnit or TransformPaths. */
4214
+ Source?: string;
4215
+ /**
4216
+ * Format: uuid
4217
+ * @description The Space of the unit the change was made in.
4218
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4219
+ */
4220
+ SpaceID?: string;
4221
+ /** @description The slug of the Space of the unit the change was made in. */
4222
+ SpaceSlug?: string;
4223
+ /** @description The Tags that mark the Revision. */
4224
+ TagIDs?: components["schemas"]["UUID"][];
4225
+ /** @description The slugs of the Tags that mark the Revision. */
4226
+ Tags?: string[];
4227
+ /** @description The slug of the Trigger that made the change. */
4228
+ Trigger?: string;
4229
+ /**
4230
+ * Format: uuid
4231
+ * @description The Trigger that made the change, if one did.
4232
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4233
+ */
4234
+ TriggerID?: string;
4235
+ /**
4236
+ * Format: uuid
4237
+ * @description The unit the change was made in.
4238
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4239
+ */
4240
+ UnitID?: string;
4241
+ /** @description The slug of the unit the change was made in. */
4242
+ UnitSlug?: string;
4243
+ /** @description The username of the user who made the change, or automation for a change made by no user. */
4244
+ User?: string;
4245
+ /**
4246
+ * Format: uuid
4247
+ * @description The user who made the change; absent for one made by no user.
4248
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4249
+ */
4250
+ UserID?: string;
4251
+ /**
4252
+ * Format: date-time
4253
+ * @description When the Revision was made.
4254
+ * @example 2006-01-02T15:04:05Z07:00
4255
+ */
4256
+ When?: string;
4257
+ };
4258
+ BlamePathChange: {
4259
+ /** @description The Mutation that recorded the change, with its Link, Trigger, Invocation and merge source. */
4260
+ Mutation?: components["schemas"]["ExtendedMutation"];
4261
+ /** @description What the unit's record says the change did to the field: Add, Update, Replace or Delete. Returned in History. */
4262
+ MutationType?: string;
4263
+ /** @description The change, as a chain hop. */
4264
+ Origin?: components["schemas"]["BlameOrigin"];
4265
+ /** @description The Revision the change made, with its user, ChangeOrders, Releases and Tags. */
4266
+ Revision?: components["schemas"]["ExtendedRevision"];
4267
+ /** @description The value the change recorded for the field. Returned in History. */
4268
+ Value?: string;
4269
+ };
4270
+ BlameValidation: {
4271
+ /** @description The result's free-text messages, where the function gave no Issues. */
4272
+ Details?: string[];
4273
+ /** @description The validating function that failed. */
4274
+ Function?: string;
4275
+ /** @description The check, as <space slug>/<trigger slug>/<function name>, the key of ValidationErrors, ValidationWarnings and ValidationResults on the Unit. */
4276
+ Gate?: string;
4277
+ /** @description What is wrong, as the function put it. */
4278
+ Issues?: components["schemas"]["Issue"][];
4279
+ /** @description What the result named, when it named an ancestor of the field, or the field by its position in an array rather than by its path. */
4280
+ Path?: string;
4281
+ /** @description The severity the function gave the finding, if it gives one. */
4282
+ Score?: string;
4283
+ /**
4284
+ * Format: uuid
4285
+ * @description The Trigger that ran the check. The gate names it by the slugs it had when it ran.
4286
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
4287
+ */
4288
+ TriggerID?: string;
4289
+ /** @description What the function found at the path, when it reported it. */
4290
+ Value?: unknown;
4291
+ /** @description True for a check of a Trigger with Warn set, whose failures do not block a release. */
4292
+ Warning?: boolean;
4293
+ };
4006
4294
  BrowserSessionResponse: {
4007
4295
  ExpiresIn?: number;
4008
4296
  Ticket?: string;
@@ -5559,6 +5847,7 @@ interface components {
5559
5847
  UnreleasedUnitCount?: number;
5560
5848
  /** Format: int64 */
5561
5849
  UpgradableUnitCount?: number;
5850
+ UpstreamSpace?: components["schemas"]["Space"];
5562
5851
  /** @description The values of the columns of the View named by the view parameter, in the View's column order. A column that selects several values, such as one with a wildcard, has an entry for each, all with the column's Name. */
5563
5852
  ViewColumns?: components["schemas"]["ViewColumn"][];
5564
5853
  /** Format: int64 */
@@ -7723,9 +8012,10 @@ interface components {
7723
8012
  readonly UpdatedAt?: string;
7724
8013
  /**
7725
8014
  * Format: uuid
8015
+ * @description Reference to the Space this Space takes its configuration from, which promotion takes from: the Space it was cloned from, which a clone sets, or one set since. Setting it requires Use on that Space. (optional)
7726
8016
  * @example 248df4b7-aa70-47b8-a036-33ac447e668d
7727
8017
  */
7728
- readonly UpstreamSpaceID?: string;
8018
+ UpstreamSpaceID?: string;
7729
8019
  /**
7730
8020
  * Format: int64
7731
8021
  * @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update.
@@ -8384,6 +8674,24 @@ interface components {
8384
8674
  */
8385
8675
  Version?: number;
8386
8676
  };
8677
+ UnitBlame: {
8678
+ /** @description Why the unit's blame could not be read, in a SearchUnitBlame response. */
8679
+ Error?: components["schemas"]["ResponseError"];
8680
+ /** @description The unit's fields the request selected, each with what set its value and everything else recorded about it, in resource and path order. */
8681
+ Fields?: components["schemas"]["BlameField"][];
8682
+ /**
8683
+ * Format: uuid
8684
+ * @description The Space of the unit.
8685
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
8686
+ */
8687
+ SpaceID?: string;
8688
+ /**
8689
+ * Format: uuid
8690
+ * @description The unit.
8691
+ * @example 248df4b7-aa70-47b8-a036-33ac447e668d
8692
+ */
8693
+ UnitID?: string;
8694
+ };
8387
8695
  UnitConflictSelector: {
8388
8696
  /** @description Match conflicts at this path; empty matches any path, including resource-level conflicts */
8389
8697
  Path?: string;
@@ -8391,6 +8699,8 @@ interface components {
8391
8699
  Reason?: string;
8392
8700
  /** @description Match conflicts on this resource; empty matches any resource */
8393
8701
  ResourceName?: string;
8702
+ /** @description Match conflicts on resources of this type, in any API version; empty matches any type. With ResourceName, it picks out one of several resources of that name. */
8703
+ ResourceType?: string;
8394
8704
  };
8395
8705
  UnitConflictsRequest: {
8396
8706
  /** @description Apply re-applies the withheld change; Dismiss drops the conflict without changing the configuration data */
@@ -8626,6 +8936,28 @@ interface components {
8626
8936
  */
8627
8937
  UnitID?: string;
8628
8938
  };
8939
+ UnitPathReport: {
8940
+ /** @description The path's own annotations other than guards, by kind. The field's Guards are those that apply to it, its ancestors' and its resource's included. */
8941
+ Annotations?: {
8942
+ [key: string]: {
8943
+ [key: string]: string;
8944
+ };
8945
+ };
8946
+ /** @description The field's chain: the changes that put the value here, from this unit out to where it was set, each with the Mutation and Revision it was read from. */
8947
+ Changes?: components["schemas"]["BlamePathChange"][];
8948
+ /** @description The field, as the unit's blame reports it, without its Chain: Changes carries the chain with its records. */
8949
+ Field?: components["schemas"]["BlameField"];
8950
+ /** @description Every change this unit recorded to the field, oldest first; returned when history is requested. */
8951
+ History?: components["schemas"]["BlamePathChange"][];
8952
+ /** @description Names, as space/slug, of the Units and Targets the report's records refer to by ID alone: the other unit of each conflict, each Link's upstream unit, each merge source, and each Release's Target. */
8953
+ Names?: {
8954
+ [key: string]: string;
8955
+ };
8956
+ /** @description ReleaseState in words, naming the revisions. */
8957
+ ReleaseMessage?: string;
8958
+ /** @description Whether the unit's last Release includes the value: Released, NeverReleased, ChangedSinceRelease, or NothingToRelease in a Space with no release Target. Absent for a field the unit does not have. */
8959
+ ReleaseState?: string;
8960
+ };
8629
8961
  UnitProtectionRequest: {
8630
8962
  /** @description Per-resource Protected edits to apply to the Unit's MutationSources */
8631
8963
  ResourceProtection?: components["schemas"]["ResourceProtection"][] | null;
@@ -10169,7 +10501,7 @@ interface operations {
10169
10501
  * The attribute names are case-sensitive, PascalCase, and
10170
10502
  * expected in a comma-separated list format as in the JSON encoding.
10171
10503
  *
10172
- * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs.
10504
+ * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs, UpstreamSpaceID.
10173
10505
  *
10174
10506
  * The whole string must be query-encoded.
10175
10507
  */
@@ -10277,6 +10609,8 @@ interface operations {
10277
10609
  Slug?: string | null;
10278
10610
  /** Format: uuid */
10279
10611
  TriggerFilterID?: string | null;
10612
+ /** Format: uuid */
10613
+ UpstreamSpaceID?: string | null;
10280
10614
  /** @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update. */
10281
10615
  Version?: number | null;
10282
10616
  WhereAttribute?: string | null;
@@ -10469,7 +10803,7 @@ interface operations {
10469
10803
  * The attribute names are case-sensitive, PascalCase, and
10470
10804
  * expected in a comma-separated list format as in the JSON encoding.
10471
10805
  *
10472
- * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs.
10806
+ * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs, UpstreamSpaceID.
10473
10807
  *
10474
10808
  * The whole string must be query-encoded.
10475
10809
  */
@@ -10677,7 +11011,7 @@ interface operations {
10677
11011
  * The attribute names are case-sensitive, PascalCase, and
10678
11012
  * expected in a comma-separated list format as in the JSON encoding.
10679
11013
  *
10680
- * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs.
11014
+ * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs, UpstreamSpaceID.
10681
11015
  *
10682
11016
  * The whole string must be query-encoded.
10683
11017
  */
@@ -10733,6 +11067,8 @@ interface operations {
10733
11067
  Slug?: string | null;
10734
11068
  /** Format: uuid */
10735
11069
  TriggerFilterID?: string | null;
11070
+ /** Format: uuid */
11071
+ UpstreamSpaceID?: string | null;
10736
11072
  /** @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update. */
10737
11073
  Version?: number | null;
10738
11074
  WhereAttribute?: string | null;
@@ -28003,7 +28339,7 @@ interface operations {
28003
28339
  * The attribute names are case-sensitive, PascalCase, and
28004
28340
  * expected in a comma-separated list format as in the JSON encoding.
28005
28341
  *
28006
- * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs.
28342
+ * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs, UpstreamSpaceID.
28007
28343
  *
28008
28344
  * The whole string must be query-encoded.
28009
28345
  */
@@ -28251,7 +28587,7 @@ interface operations {
28251
28587
  * The attribute names are case-sensitive, PascalCase, and
28252
28588
  * expected in a comma-separated list format as in the JSON encoding.
28253
28589
  *
28254
- * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs.
28590
+ * Supported attributes for Space are AttributeFilterID, AttributeIDs, ComponentID, OrganizationID, Permissions, ReleaseTargetID, TriggerFilterID, TriggerIDs, UpstreamSpaceID.
28255
28591
  *
28256
28592
  * The whole string must be query-encoded.
28257
28593
  */
@@ -28588,6 +28924,8 @@ interface operations {
28588
28924
  Slug?: string | null;
28589
28925
  /** Format: uuid */
28590
28926
  TriggerFilterID?: string | null;
28927
+ /** Format: uuid */
28928
+ UpstreamSpaceID?: string | null;
28591
28929
  /** @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update. */
28592
28930
  Version?: number | null;
28593
28931
  WhereAttribute?: string | null;
@@ -42294,6 +42632,102 @@ interface operations {
42294
42632
  };
42295
42633
  };
42296
42634
  };
42635
+ GetUnitBlame: {
42636
+ parameters: {
42637
+ query?: {
42638
+ /** @description Only the fields whose path contains this substring. */
42639
+ path?: string;
42640
+ /** @description Only the fields of this resource, named as <type>/<name> or <name>; a substring of either matches. */
42641
+ resource?: string;
42642
+ /**
42643
+ * @description Only the fields with at least one of these flags, comma-separated. Conflict,Absent,Finding,ValidationError,ValidationWarning selects the fields that need attention.
42644
+ *
42645
+ * Supported values: Protected, Guarded, Conflict, Absent, Finding, ValidationError, ValidationWarning, Upgraded, SetByLink, SetByTrigger, ChangeOrder, Unreleased, Needed, Provided.
42646
+ */
42647
+ flags?: string;
42648
+ /** @description Follow each merge and Link resolve into the unit it took the value from, to where the value was set. Default true; false reports each unit's own record, which names the upstream unit without reading it. */
42649
+ upstream?: boolean;
42650
+ /** @description How many upstream units to follow before stopping. */
42651
+ upstream_depth?: number;
42652
+ /** @description Include the $comment$ pseudo-fields that carry YAML comments. */
42653
+ include_comments?: boolean;
42654
+ };
42655
+ header?: never;
42656
+ path: {
42657
+ /** @description Unique identifier for a space_id */
42658
+ space_id: string;
42659
+ /** @description Unique identifier for a unit_id */
42660
+ unit_id: string;
42661
+ };
42662
+ cookie?: never;
42663
+ };
42664
+ requestBody?: never;
42665
+ responses: {
42666
+ /** @description OK */
42667
+ 200: {
42668
+ headers: {
42669
+ [name: string]: unknown;
42670
+ };
42671
+ content: {
42672
+ "application/json": components["schemas"]["UnitBlame"];
42673
+ };
42674
+ };
42675
+ /** @description Unit request is invalid (Bad Request). */
42676
+ 400: {
42677
+ headers: {
42678
+ [name: string]: unknown;
42679
+ };
42680
+ content: {
42681
+ "application/json": components["schemas"]["StandardErrorResponse"];
42682
+ };
42683
+ };
42684
+ /** @description Unauthorized access. */
42685
+ 401: {
42686
+ headers: {
42687
+ [name: string]: unknown;
42688
+ };
42689
+ content: {
42690
+ "application/json": components["schemas"]["StandardErrorResponse"];
42691
+ };
42692
+ };
42693
+ /** @description Forbidden access. */
42694
+ 403: {
42695
+ headers: {
42696
+ [name: string]: unknown;
42697
+ };
42698
+ content: {
42699
+ "application/json": components["schemas"]["StandardErrorResponse"];
42700
+ };
42701
+ };
42702
+ /** @description Unit not found. */
42703
+ 404: {
42704
+ headers: {
42705
+ [name: string]: unknown;
42706
+ };
42707
+ content: {
42708
+ "application/json": components["schemas"]["StandardErrorResponse"];
42709
+ };
42710
+ };
42711
+ /** @description Something went wrong while processing Unit. */
42712
+ 500: {
42713
+ headers: {
42714
+ [name: string]: unknown;
42715
+ };
42716
+ content: {
42717
+ "application/json": components["schemas"]["StandardErrorResponse"];
42718
+ };
42719
+ };
42720
+ /** @description Unexpected error. */
42721
+ default: {
42722
+ headers: {
42723
+ [name: string]: unknown;
42724
+ };
42725
+ content: {
42726
+ "application/json": components["schemas"]["StandardErrorResponse"];
42727
+ };
42728
+ };
42729
+ };
42730
+ };
42297
42731
  ResolveUnitConflicts: {
42298
42732
  parameters: {
42299
42733
  query?: never;
@@ -43184,6 +43618,96 @@ interface operations {
43184
43618
  };
43185
43619
  };
43186
43620
  };
43621
+ GetUnitPath: {
43622
+ parameters: {
43623
+ query: {
43624
+ /** @description The field: its REF, a prefix of a REF of at least four characters, or its path. */
43625
+ field: string;
43626
+ /** @description Also return every change the Unit recorded to the field. Reads the record of every Revision of the Unit. */
43627
+ history?: boolean;
43628
+ /** @description Only the fields of this resource, named as <type>/<name> or <name>; a substring of either matches. */
43629
+ resource?: string;
43630
+ /** @description Follow each merge and Link resolve into the unit it took the value from, to where the value was set. Default true; false reports each unit's own record, which names the upstream unit without reading it. */
43631
+ upstream?: boolean;
43632
+ /** @description How many upstream units to follow before stopping. */
43633
+ upstream_depth?: number;
43634
+ };
43635
+ header?: never;
43636
+ path: {
43637
+ /** @description Unique identifier for a space_id */
43638
+ space_id: string;
43639
+ /** @description Unique identifier for a unit_id */
43640
+ unit_id: string;
43641
+ };
43642
+ cookie?: never;
43643
+ };
43644
+ requestBody?: never;
43645
+ responses: {
43646
+ /** @description OK */
43647
+ 200: {
43648
+ headers: {
43649
+ [name: string]: unknown;
43650
+ };
43651
+ content: {
43652
+ "application/json": components["schemas"]["UnitPathReport"];
43653
+ };
43654
+ };
43655
+ /** @description Unit request is invalid (Bad Request). */
43656
+ 400: {
43657
+ headers: {
43658
+ [name: string]: unknown;
43659
+ };
43660
+ content: {
43661
+ "application/json": components["schemas"]["StandardErrorResponse"];
43662
+ };
43663
+ };
43664
+ /** @description Unauthorized access. */
43665
+ 401: {
43666
+ headers: {
43667
+ [name: string]: unknown;
43668
+ };
43669
+ content: {
43670
+ "application/json": components["schemas"]["StandardErrorResponse"];
43671
+ };
43672
+ };
43673
+ /** @description Forbidden access. */
43674
+ 403: {
43675
+ headers: {
43676
+ [name: string]: unknown;
43677
+ };
43678
+ content: {
43679
+ "application/json": components["schemas"]["StandardErrorResponse"];
43680
+ };
43681
+ };
43682
+ /** @description Unit not found. */
43683
+ 404: {
43684
+ headers: {
43685
+ [name: string]: unknown;
43686
+ };
43687
+ content: {
43688
+ "application/json": components["schemas"]["StandardErrorResponse"];
43689
+ };
43690
+ };
43691
+ /** @description Something went wrong while processing Unit. */
43692
+ 500: {
43693
+ headers: {
43694
+ [name: string]: unknown;
43695
+ };
43696
+ content: {
43697
+ "application/json": components["schemas"]["StandardErrorResponse"];
43698
+ };
43699
+ };
43700
+ /** @description Unexpected error. */
43701
+ default: {
43702
+ headers: {
43703
+ [name: string]: unknown;
43704
+ };
43705
+ content: {
43706
+ "application/json": components["schemas"]["StandardErrorResponse"];
43707
+ };
43708
+ };
43709
+ };
43710
+ };
43187
43711
  SetUnitProtection: {
43188
43712
  parameters: {
43189
43713
  query?: never;
@@ -50019,19 +50543,612 @@ interface operations {
50019
50543
  * An example conjunction is:
50020
50544
  * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
50021
50545
  *
50022
- * Supported attributes for filtering on Space: Annotations, AttributeFilterID, AttributeHash, AttributeIDs, BackingUnitID, ComponentID, CreatedAt, DeleteGates, DisplayName, HiddenReason, Labels, OCIRepositoryURL, OrganizationID, Permissions, ReleaseTargetID, Slug, SpaceID, TriggerFilterID, TriggerHash, TriggerIDs, UpdatedAt, UpstreamSpaceID.
50546
+ * Supported attributes for filtering on Space: Annotations, AttributeFilterID, AttributeHash, AttributeIDs, BackingUnitID, ComponentID, CreatedAt, DeleteGates, DisplayName, HiddenReason, Labels, OCIRepositoryURL, OrganizationID, Permissions, ReleaseTargetID, Slug, SpaceID, TriggerFilterID, TriggerHash, TriggerIDs, UpdatedAt, UpstreamSpaceID.
50547
+ *
50548
+ * Where expression to select destination spaces for cloning units
50549
+ *
50550
+ * The whole string must be query-encoded.
50551
+ */
50552
+ where_space?: string;
50553
+ /**
50554
+ * @description UUID of a Filter entity to apply to the Space list.
50555
+ *
50556
+ * The Filter must be in the same Organization as the user credentials.
50557
+ *
50558
+ * The Filter's From field must match the entity type being filtered (Space).
50559
+ *
50560
+ * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
50561
+ *
50562
+ * The Filter's Where clause will be combined with any explicit 'where' parameter using AND logic.
50563
+ *
50564
+ * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
50565
+ */
50566
+ filter_space?: string;
50567
+ /** @description Allowed values are true and false. Default is false. When true, reports success when an entity already exists and returns the existing entity */
50568
+ allow_exists?: string;
50569
+ /**
50570
+ * @description The specified string is an expression for the purpose of filtering
50571
+ * the list of Links returned. The expression syntax was inspired by SQL.
50572
+ * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50573
+ * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50574
+ * as in the JSON encoding.
50575
+ * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50576
+ * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50577
+ * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50578
+ * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50579
+ * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
50580
+ * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
50581
+ * UUIDs and boolean attributes support equality and inequality only.
50582
+ * UUID and time literals must be quoted as string literals.
50583
+ * String literals are quoted with single quotes, such as `'string'`.
50584
+ * Time literals use the same form as when serialized as JSON,
50585
+ * such as: `CreatedAt > '2025-02-18T23:16:34'`.
50586
+ * Integer and boolean literals are also supported for attributes of those types.
50587
+ * Arrays support the `?` operator to to match any element of the array,
50588
+ * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
50589
+ * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
50590
+ * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
50591
+ * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
50592
+ * Without the `*` such a reference is an error, since it names no single value to compare.
50593
+ * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
50594
+ * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
50595
+ * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
50596
+ * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
50597
+ * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
50598
+ * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
50599
+ * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
50600
+ * Conjunctions are supported using the `AND` operator.
50601
+ * An example conjunction is:
50602
+ * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
50603
+ *
50604
+ * Supported attributes for filtering on Link: Annotations, AutoUpdate, BackingUnitID, Bindings, Clearance, CreatedAt, DeleteGates, DisplayName, DownstreamLastMergedRevisionNum, DownstreamPaths, DownstreamSetters, FromUnitID, Guards, Hash, HiddenReason, Labels, LinkID, ManualBindings, MergeEnableSubtraction, OrganizationID, Permissions, Protect, Slug, SpaceID, Squash, Stale, ToSpaceID, ToUnitID, TransformInvocationID, UpdateType, UpdatedAt, UpstreamGetters, UpstreamLastMergedRevisionNum, UpstreamLinkID, UpstreamPaths, UpstreamSpaceID.
50605
+ *
50606
+ * Where expression to filter outgoing links (links to units outside the cloned set) for copying. If non-empty, matching outgoing links are also copied with FromUnitID retargeted to the cloned unit.
50607
+ *
50608
+ * The whole string must be query-encoded.
50609
+ */
50610
+ include_outgoing_links_where?: string;
50611
+ /** @description Revision of the upstream Unit to copy. The default is its head, which is what a clone has always taken. Takes the same forms as merge_end and restore -- a revision number, a named revision, 'Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Before:...' -- resolved against the Unit being cloned from, so a bulk clone lands on a different revision of each source Unit. 'Before:ChangeOrder:uuid' is what a promotion uses: it names the state the change starts from, which for a Unit no target has taken yet is its first revision, so the upgrade that follows replays the change into the clone rather than the clone arriving with the change already folded in. Requires upstream_unit_id (or, in bulk, a source Unit to clone). */
50612
+ upstream_revision?: string;
50613
+ /** @description Also create a MergeUnits Link from each upstream Unit back to its clone, alongside the UpgradeUnit Link a clone always gets. The upgrade Link carries changes from the upstream Unit into the clone; this one carries them the other way, which is what makes a clone usable as a draft: change it, review it, then resolve the Link (resolve=Link:...) on the upstream Unit to merge the change home. A Unit may be the source of several of these -- one per outstanding draft -- so each is named for the clone it takes changes from (syncback-<space>-<unit>) rather than for the Unit they all point at. The Link is created in the upstream Unit's Space, which the caller must be allowed to create Links in. Requires upstream_unit_id (or, in bulk, a source Unit to clone). */
50614
+ syncback?: boolean;
50615
+ /** @description If true, report what the write would do without doing it: the write runs, including every check it makes, and is then rolled back. The response is the one the write would return, with the entities as they would be written. An entity a dry run creates is given an ID that the real create will not reuse. */
50616
+ dry_run?: boolean;
50617
+ };
50618
+ header?: never;
50619
+ path?: never;
50620
+ cookie?: never;
50621
+ };
50622
+ requestBody?: {
50623
+ content: {
50624
+ "application/merge-patch+json": {
50625
+ /** @description An optional map of Annotation key/value pairs for tools to attach information to entities. */
50626
+ Annotations?: {
50627
+ [key: string]: string | null;
50628
+ } | null;
50629
+ /**
50630
+ * Format: uuid
50631
+ * @description Unique identifier for the ChangeSet to which the current Revision belongs. Optional. Units are not required to belong to ChangeSets.
50632
+ */
50633
+ ChangeSetID?: string | null;
50634
+ /** @description An optional set of gates that, if any is present, will block deletion */
50635
+ DeleteGates?: {
50636
+ [key: string]: boolean | null;
50637
+ } | null;
50638
+ /** @description An optional set of gates that, if any is present, will block destroy operations */
50639
+ DestroyGates?: {
50640
+ [key: string]: boolean | null;
50641
+ } | null;
50642
+ /** @description Friendly name for the entity. */
50643
+ DisplayName?: string | null;
50644
+ /** @description The reason the entity is hidden, if it is. A hidden entity is left out of List and Search results, and of what bulk operations act on, unless the include_hidden parameter names its reason or is *, or the where parameter names the entity by Slug or ID. ConfigHub/YAML Units are created hidden with the reason BackingUnit unless given another. */
50645
+ HiddenReason?: string | null;
50646
+ /** @description An optional map of Label key/value pairs to specify identifying attributes of entities for the purpose of grouping and filtering them. */
50647
+ Labels?: {
50648
+ [key: string]: string | null;
50649
+ } | null;
50650
+ /** @description LastChangeDescription is a human-readable description of the last change. This description is copied to the new Revision when the Data is changed. */
50651
+ LastChangeDescription?: string | null;
50652
+ Permissions?: {
50653
+ [key: string]: Record<string, never> | null;
50654
+ } | null;
50655
+ /** @description Unique URL-safe identifier for the entity. */
50656
+ Slug?: string | null;
50657
+ /** @description ToolchainType specifies the type of toolchain for this unit. Possible values include "Kubernetes/YAML", "AppConfig/Properties", "AppConfig/YAML", "AppConfig/TOML", "AppConfig/INI", "AppConfig/JSON", "AppConfig/Env", "AppConfig/Text", "ConfigHub/YAML". */
50658
+ ToolchainType?: string | null;
50659
+ Unreleasable?: boolean | null;
50660
+ /** @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update. */
50661
+ Version?: number | null;
50662
+ };
50663
+ };
50664
+ };
50665
+ responses: {
50666
+ /** @description OK */
50667
+ 200: {
50668
+ headers: {
50669
+ /** @description The token to pass as the continue parameter of the next request, when there may be more entities after this page. It is absent on the last page. A page can hold fewer entities than the limit, or none, and still have one. */
50670
+ "ConfigHub-Continue"?: string;
50671
+ [name: string]: unknown;
50672
+ };
50673
+ content: {
50674
+ "application/json": components["schemas"]["UnitCreateOrUpdateResponse"][];
50675
+ };
50676
+ };
50677
+ /** @description Multi-Status (partial success) */
50678
+ 207: {
50679
+ headers: {
50680
+ [name: string]: unknown;
50681
+ };
50682
+ content: {
50683
+ "application/json": components["schemas"]["UnitCreateOrUpdateResponse"][];
50684
+ };
50685
+ };
50686
+ /** @description Unit request is invalid (Bad Request). */
50687
+ 400: {
50688
+ headers: {
50689
+ [name: string]: unknown;
50690
+ };
50691
+ content: {
50692
+ "application/json": components["schemas"]["StandardErrorResponse"];
50693
+ };
50694
+ };
50695
+ /** @description Unauthorized access. */
50696
+ 401: {
50697
+ headers: {
50698
+ [name: string]: unknown;
50699
+ };
50700
+ content: {
50701
+ "application/json": components["schemas"]["StandardErrorResponse"];
50702
+ };
50703
+ };
50704
+ /** @description Forbidden access. */
50705
+ 403: {
50706
+ headers: {
50707
+ [name: string]: unknown;
50708
+ };
50709
+ content: {
50710
+ "application/json": components["schemas"]["StandardErrorResponse"];
50711
+ };
50712
+ };
50713
+ /** @description Unit not found. */
50714
+ 404: {
50715
+ headers: {
50716
+ [name: string]: unknown;
50717
+ };
50718
+ content: {
50719
+ "application/json": components["schemas"]["StandardErrorResponse"];
50720
+ };
50721
+ };
50722
+ /** @description Unit data conflict. Data has changed since last read. */
50723
+ 409: {
50724
+ headers: {
50725
+ [name: string]: unknown;
50726
+ };
50727
+ content: {
50728
+ "application/json": components["schemas"]["StandardErrorResponse"];
50729
+ };
50730
+ };
50731
+ /** @description Unable to create unit(s) due to configuration data problem */
50732
+ 422: {
50733
+ headers: {
50734
+ [name: string]: unknown;
50735
+ };
50736
+ content: {
50737
+ "application/json": components["schemas"]["StandardErrorResponse"];
50738
+ };
50739
+ };
50740
+ /** @description Something went wrong while processing Unit. */
50741
+ 500: {
50742
+ headers: {
50743
+ [name: string]: unknown;
50744
+ };
50745
+ content: {
50746
+ "application/json": components["schemas"]["StandardErrorResponse"];
50747
+ };
50748
+ };
50749
+ /** @description Unexpected error. */
50750
+ default: {
50751
+ headers: {
50752
+ [name: string]: unknown;
50753
+ };
50754
+ content: {
50755
+ "application/json": components["schemas"]["StandardErrorResponse"];
50756
+ };
50757
+ };
50758
+ };
50759
+ };
50760
+ BulkDeleteUnits: {
50761
+ parameters: {
50762
+ query?: {
50763
+ /**
50764
+ * @description The specified string is an expression for the purpose of filtering
50765
+ * the list of Units returned. The expression syntax was inspired by SQL.
50766
+ * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50767
+ * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50768
+ * as in the JSON encoding.
50769
+ * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50770
+ * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50771
+ * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50772
+ * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50773
+ * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
50774
+ * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
50775
+ * UUIDs and boolean attributes support equality and inequality only.
50776
+ * UUID and time literals must be quoted as string literals.
50777
+ * String literals are quoted with single quotes, such as `'string'`.
50778
+ * Time literals use the same form as when serialized as JSON,
50779
+ * such as: `CreatedAt > '2025-02-18T23:16:34'`.
50780
+ * Integer and boolean literals are also supported for attributes of those types.
50781
+ * Arrays support the `?` operator to to match any element of the array,
50782
+ * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
50783
+ * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
50784
+ * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
50785
+ * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
50786
+ * Without the `*` such a reference is an error, since it names no single value to compare.
50787
+ * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
50788
+ * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
50789
+ * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
50790
+ * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
50791
+ * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
50792
+ * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
50793
+ * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
50794
+ * Conjunctions are supported using the `AND` operator.
50795
+ * An example conjunction is:
50796
+ * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
50797
+ *
50798
+ * Supported attributes for filtering on Unit: Annotations, ApplyGates, ApplyWarnings, ChangeSetID, Conflicts, CreatedAt, DataHash, DeleteGates, DestroyGates, DisplayName, FromLinkID, HeadRevisionID, HeadRevisionNum, HeadUnitEventNum, HiddenReason, Labels, LastChangeDescription, LastReleasedRevisionNum, LinkFindings, NeededPaths, OrganizationID, Permissions, ProvidedPaths, Slug, SpaceID, TargetID, ToolchainType, UnitID, Unreleasable, UpdatedAt, UpstreamRevisionNum, UpstreamSpaceID, UpstreamUnitID, ValidationErrors, ValidationResults, ValidationTriggerIDs, ValidationWarnings, ValueTriggerIDs, Values.
50799
+ *
50800
+ * Finding all units created by cloning can be done using the expression `UpstreamRevisionNum > 0`. Clones of a specific unit can be found by additionally filtering based on `UpstreamUnitID`. Units never released can be found using `LastReleasedRevisionNum = 0`. Units with unreleased changes can be found with `HeadRevisionNum > LastReleasedRevisionNum AND ReleaseTargetID IS NOT NULL AND Unreleasable = false`.
50801
+ *
50802
+ * The whole string must be query-encoded.
50803
+ */
50804
+ where?: string;
50805
+ /**
50806
+ * @description UUID of a Filter entity to apply to the Unit list.
50807
+ *
50808
+ * The Filter must be in the same Organization as the user credentials.
50809
+ *
50810
+ * The Filter's From field must match the entity type being filtered (Unit).
50811
+ *
50812
+ * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
50813
+ *
50814
+ * The Filter's Where clause will be combined with any explicit 'where' parameter using AND logic.
50815
+ *
50816
+ * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
50817
+ */
50818
+ filter?: string;
50819
+ /**
50820
+ * @description Free text search that approximately matches the specified string against string fields and map keys/values.
50821
+ *
50822
+ * The search is case-insensitive and uses pattern matching to find entities containing the text.
50823
+ *
50824
+ * Searchable string fields include attributes like Slug, DisplayName, and string-typed custom fields.
50825
+ *
50826
+ * For map fields (like Labels and Annotations), the search matches both map keys and values.
50827
+ *
50828
+ * The search uses OR logic across all searchable fields, so matching any field will return the entity.
50829
+ *
50830
+ * If both 'where' and 'contains' parameters are specified, they are combined with AND logic.
50831
+ *
50832
+ * Searchable fields for Unit include string and map-type attributes from the queryable attributes list.
50833
+ *
50834
+ * The whole string must be query-encoded.
50835
+ */
50836
+ contains?: string;
50837
+ /**
50838
+ * @description Hidden Unit entities, those with a HiddenReason, are left out of the results, or of what a bulk operation acts on, unless this names their HiddenReason.
50839
+ *
50840
+ * It is a comma-separated list of HiddenReasons, or `*` for all of them.
50841
+ *
50842
+ * A where clause naming the entities, by their Slug or ID with `=` or `IN`, or naming HiddenReason at all, also returns hidden entities it selects.
50843
+ *
50844
+ * ConfigHub/YAML Units, which hold the configuration of entities, are hidden with the HiddenReason `BackingUnit`.
50845
+ */
50846
+ include_hidden?: string;
50847
+ /**
50848
+ * @description Include clause for expanding related entities in the response for Unit.
50849
+ * The attribute names are case-sensitive, PascalCase, and
50850
+ * expected in a comma-separated list format as in the JSON encoding.
50851
+ *
50852
+ * Supported attributes for Unit are ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID.
50853
+ *
50854
+ * The whole string must be query-encoded.
50855
+ */
50856
+ include?: string;
50857
+ /** @description Maximum number of Unit entities to act on, in ID order. A request that names limit or continue also stops when it runs short of time, and returns a ConfigHub-Continue header to pass as the continue parameter of the next request; keep sending requests until a response has none. If neither is specified, the request acts on every selected entity. */
50858
+ limit?: number;
50859
+ /** @description The token from the ConfigHub-Continue header of the previous request, to act on the Unit entities after the last one it acted on. The request's other parameters, except limit, must be the same as those of the request that returned the token. */
50860
+ continue?: string;
50861
+ /** @description If true, remove the references to the deleted entities from entities the request does not delete, instead of refusing the delete while any remain. References that cannot be removed still refuse it. For a Space, applies to everything the recursive delete removes. */
50862
+ detach?: boolean;
50863
+ };
50864
+ header?: never;
50865
+ path?: never;
50866
+ cookie?: never;
50867
+ };
50868
+ requestBody?: never;
50869
+ responses: {
50870
+ /** @description OK */
50871
+ 200: {
50872
+ headers: {
50873
+ /** @description The token to pass as the continue parameter of the next request, when there may be more entities after this page. It is absent on the last page. A page can hold fewer entities than the limit, or none, and still have one. */
50874
+ "ConfigHub-Continue"?: string;
50875
+ [name: string]: unknown;
50876
+ };
50877
+ content: {
50878
+ "application/json": components["schemas"]["DeleteResponse"][];
50879
+ };
50880
+ };
50881
+ /** @description Multi-Status: Mixed success and failure results */
50882
+ 207: {
50883
+ headers: {
50884
+ [name: string]: unknown;
50885
+ };
50886
+ content: {
50887
+ "application/json": components["schemas"]["DeleteResponse"][];
50888
+ };
50889
+ };
50890
+ /** @description Unit request is invalid (Bad Request). */
50891
+ 400: {
50892
+ headers: {
50893
+ [name: string]: unknown;
50894
+ };
50895
+ content: {
50896
+ "application/json": components["schemas"]["StandardErrorResponse"];
50897
+ };
50898
+ };
50899
+ /** @description Unauthorized access. */
50900
+ 401: {
50901
+ headers: {
50902
+ [name: string]: unknown;
50903
+ };
50904
+ content: {
50905
+ "application/json": components["schemas"]["StandardErrorResponse"];
50906
+ };
50907
+ };
50908
+ /** @description Forbidden access. */
50909
+ 403: {
50910
+ headers: {
50911
+ [name: string]: unknown;
50912
+ };
50913
+ content: {
50914
+ "application/json": components["schemas"]["StandardErrorResponse"];
50915
+ };
50916
+ };
50917
+ /** @description Unit not found. */
50918
+ 404: {
50919
+ headers: {
50920
+ [name: string]: unknown;
50921
+ };
50922
+ content: {
50923
+ "application/json": components["schemas"]["StandardErrorResponse"];
50924
+ };
50925
+ };
50926
+ /** @description Unit is still in use: it has DeleteGates, or other entities still reference it. Or data has changed since last read. */
50927
+ 409: {
50928
+ headers: {
50929
+ [name: string]: unknown;
50930
+ };
50931
+ content: {
50932
+ "application/json": components["schemas"]["StandardErrorResponse"];
50933
+ };
50934
+ };
50935
+ /** @description Unable to delete entity */
50936
+ 422: {
50937
+ headers: {
50938
+ [name: string]: unknown;
50939
+ };
50940
+ content: {
50941
+ "application/json": components["schemas"]["StandardErrorResponse"];
50942
+ };
50943
+ };
50944
+ /** @description Unable to delete entities due to a inflight operation using one or more of the entities */
50945
+ 423: {
50946
+ headers: {
50947
+ [name: string]: unknown;
50948
+ };
50949
+ content: {
50950
+ "application/json": components["schemas"]["StandardErrorResponse"];
50951
+ };
50952
+ };
50953
+ /** @description Something went wrong while processing Unit. */
50954
+ 500: {
50955
+ headers: {
50956
+ [name: string]: unknown;
50957
+ };
50958
+ content: {
50959
+ "application/json": components["schemas"]["StandardErrorResponse"];
50960
+ };
50961
+ };
50962
+ /** @description Unexpected error. */
50963
+ default: {
50964
+ headers: {
50965
+ [name: string]: unknown;
50966
+ };
50967
+ content: {
50968
+ "application/json": components["schemas"]["StandardErrorResponse"];
50969
+ };
50970
+ };
50971
+ };
50972
+ };
50973
+ BulkPatchUnits: {
50974
+ parameters: {
50975
+ query?: {
50976
+ /**
50977
+ * @description The specified string is an expression for the purpose of filtering
50978
+ * the list of Units returned. The expression syntax was inspired by SQL.
50979
+ * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50980
+ * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50981
+ * as in the JSON encoding.
50982
+ * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50983
+ * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50984
+ * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50985
+ * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50986
+ * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
50987
+ * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
50988
+ * UUIDs and boolean attributes support equality and inequality only.
50989
+ * UUID and time literals must be quoted as string literals.
50990
+ * String literals are quoted with single quotes, such as `'string'`.
50991
+ * Time literals use the same form as when serialized as JSON,
50992
+ * such as: `CreatedAt > '2025-02-18T23:16:34'`.
50993
+ * Integer and boolean literals are also supported for attributes of those types.
50994
+ * Arrays support the `?` operator to to match any element of the array,
50995
+ * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
50996
+ * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
50997
+ * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
50998
+ * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
50999
+ * Without the `*` such a reference is an error, since it names no single value to compare.
51000
+ * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
51001
+ * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
51002
+ * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
51003
+ * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
51004
+ * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
51005
+ * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
51006
+ * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
51007
+ * Conjunctions are supported using the `AND` operator.
51008
+ * An example conjunction is:
51009
+ * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
51010
+ *
51011
+ * Supported attributes for filtering on Unit: Annotations, ApplyGates, ApplyWarnings, ChangeSetID, Conflicts, CreatedAt, DataHash, DeleteGates, DestroyGates, DisplayName, FromLinkID, HeadRevisionID, HeadRevisionNum, HeadUnitEventNum, HiddenReason, Labels, LastChangeDescription, LastReleasedRevisionNum, LinkFindings, NeededPaths, OrganizationID, Permissions, ProvidedPaths, Slug, SpaceID, TargetID, ToolchainType, UnitID, Unreleasable, UpdatedAt, UpstreamRevisionNum, UpstreamSpaceID, UpstreamUnitID, ValidationErrors, ValidationResults, ValidationTriggerIDs, ValidationWarnings, ValueTriggerIDs, Values.
51012
+ *
51013
+ * Finding all units created by cloning can be done using the expression `UpstreamRevisionNum > 0`. Clones of a specific unit can be found by additionally filtering based on `UpstreamUnitID`. Units never released can be found using `LastReleasedRevisionNum = 0`. Units with unreleased changes can be found with `HeadRevisionNum > LastReleasedRevisionNum AND ReleaseTargetID IS NOT NULL AND Unreleasable = false`.
51014
+ *
51015
+ * The whole string must be query-encoded.
51016
+ */
51017
+ where?: string;
51018
+ /**
51019
+ * @description UUID of a Filter entity to apply to the Unit list.
51020
+ *
51021
+ * The Filter must be in the same Organization as the user credentials.
51022
+ *
51023
+ * The Filter's From field must match the entity type being filtered (Unit).
51024
+ *
51025
+ * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
51026
+ *
51027
+ * The Filter's Where clause will be combined with any explicit 'where' parameter using AND logic.
51028
+ *
51029
+ * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
51030
+ */
51031
+ filter?: string;
51032
+ /**
51033
+ * @description Free text search that approximately matches the specified string against string fields and map keys/values.
51034
+ *
51035
+ * The search is case-insensitive and uses pattern matching to find entities containing the text.
51036
+ *
51037
+ * Searchable string fields include attributes like Slug, DisplayName, and string-typed custom fields.
51038
+ *
51039
+ * For map fields (like Labels and Annotations), the search matches both map keys and values.
51040
+ *
51041
+ * The search uses OR logic across all searchable fields, so matching any field will return the entity.
51042
+ *
51043
+ * If both 'where' and 'contains' parameters are specified, they are combined with AND logic.
51044
+ *
51045
+ * Searchable fields for Unit include string and map-type attributes from the queryable attributes list.
51046
+ *
51047
+ * The whole string must be query-encoded.
51048
+ */
51049
+ contains?: string;
51050
+ /**
51051
+ * @description Hidden Unit entities, those with a HiddenReason, are left out of the results, or of what a bulk operation acts on, unless this names their HiddenReason.
51052
+ *
51053
+ * It is a comma-separated list of HiddenReasons, or `*` for all of them.
51054
+ *
51055
+ * A where clause naming the entities, by their Slug or ID with `=` or `IN`, or naming HiddenReason at all, also returns hidden entities it selects.
51056
+ *
51057
+ * ConfigHub/YAML Units, which hold the configuration of entities, are hidden with the HiddenReason `BackingUnit`.
51058
+ */
51059
+ include_hidden?: string;
51060
+ /**
51061
+ * @description Include clause for expanding related entities in the response for Unit.
51062
+ * The attribute names are case-sensitive, PascalCase, and
51063
+ * expected in a comma-separated list format as in the JSON encoding.
51064
+ *
51065
+ * Supported attributes for Unit are ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID.
51066
+ *
51067
+ * A write also accepts the parts of its result: ConfigData for the configuration the operation produced, MutationSources for what set each value in it, and Diff for what the operation changed, path by path with the values on both sides. None is a field of a Unit, and each costs something to return, so they are returned only when named. A dry run stores nothing, so this is the only way to see what it would have produced.
51068
+ *
51069
+ * Supported values: ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID, ConfigData, MutationSources, Diff.
51070
+ *
51071
+ * The whole string must be query-encoded.
51072
+ */
51073
+ include?: string;
51074
+ /** @description Maximum number of Unit entities to act on, in ID order. A request that names limit or continue also stops when it runs short of time, and returns a ConfigHub-Continue header to pass as the continue parameter of the next request; keep sending requests until a response has none. If neither is specified, the request acts on every selected entity. */
51075
+ limit?: number;
51076
+ /** @description The token from the ConfigHub-Continue header of the previous request, to act on the Unit entities after the last one it acted on. The request's other parameters, except limit, must be the same as those of the request that returned the token. */
51077
+ continue?: string;
51078
+ /** @description Dry run mode: return changed unit(s) but don't update configuration data */
51079
+ dry_run?: boolean;
51080
+ /** @description Record the paths this operation writes as protected local overrides, so a later merge from upstream does not overwrite them. Without it the operation claims nothing: each written path keeps whatever the Unit already has for it, and a path with no history is left unprotected. It only ever adds protection -- re-opening a path is the /protection API (cub unit set-protection --unprotect). Has no effect with restore, which rewinds MutationSources to the restored Revision's stored values wholesale. */
51081
+ protect?: boolean;
51082
+ /** @description The classes of guarded reason this operation is cleared for, as a JSON Clearance -- a list of {Key, Operator, Values} requirements, where Operator is Exists, In, NotIn, or DoesNotExist. A path whose guards this does not cover is not written, and the withheld change is reported as a Guarded conflict. An absent or empty clearance clears nothing, which only matters for a Unit that has guards. */
51083
+ clearance?: string;
51084
+ /** @description The guards this operation records on the paths it writes, as a JSON object of guard key to value -- the reasons those paths hold what they hold, so a later operation must be cleared for them before overwriting. The guard analogue of protect: protect claims the paths, this says why. It only ever adds and overwrites the keys it names -- retiring a guard is the /guard API (cub unit set-guard --remove-guard). */
51085
+ guards?: string;
51086
+ /** @description Merge the range as one rebased diff and record it as one Revision, instead of walking it. By default a merge replays: it takes the source's Revisions in order and, where a Revision records function invocations that can be re-executed, runs them against this Unit rather than rebasing their recorded paths onto it -- so a change lands where this Unit's own structure puts it -- and records each source Revision that has an effect here as a Revision of its own, carrying that Revision's change description, its own conflicts, and one Mutation per source Mutation. Squashing gives up both: the range arrives as a single rebased patch in a single Revision, which is what a merge did before replay existed. Accepted with upgrade, merge_source, and resolve of an UpgradeUnit or MergeUnits Link, and refused elsewhere, since there is no range to walk. A Link can ask for it standingly with its Squash field. */
51087
+ squash?: boolean;
51088
+ /** @description Upgrade the unit to the latest version of its upstream unit */
51089
+ upgrade?: boolean;
51090
+ /** @description Restore revision source. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
51091
+ restore?: string;
51092
+ /** @description Resolve Links from this (downstream) Unit to another (upstream) Unit, propagating what each Link's UpdateType says to propagate. Expects Link:*, Link:<uuid>, or Link:<where expression>. Link:* selects every Link from this Unit that can resolve; a where expression selects among those, evaluated against the Links themselves (e.g. UpdateType = 'MergeUnits'), which is how to name one Link in a bulk operation, where a UUID cannot be. A Link with UpdateType None resolves nothing and is never selected. An AutoUpdate Link may be resolved by hand: it does what the queue would have done, and nothing when the Link is already level with its source. */
51093
+ resolve?: string;
51094
+ /** @description Merge source unit. Currently it must be a unit ID or 'Self'. */
51095
+ merge_source?: string;
51096
+ /** @description Merge base revision, which provides the base configuration data of the changes to merge. With merge_source, this is a revision of the merge source unit. With merge_external_source, this is a revision of the unit being updated and overrides the default selection of the latest MergeExternal revision. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
51097
+ merge_base?: string;
51098
+ /** @description Merge end revision of the merge source, which provides the final configuration of the changes to merge. Also accepted with upgrade and with resolve, where it names how far along the source to take the propagation; the default there is the source's head. Naming a ChangeSet or Tag that ends a change is what leaves a change still being made at the source behind. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
51099
+ merge_end?: string;
51100
+ /** @description Identifier of the external source for merge-on-update. When set, computes mutations between the last MergeExternal revision and the provided data, then patches the current unit data with those mutations. */
51101
+ merge_external_source?: string;
51102
+ /** @description Enable the subtraction (override-preservation) step of upgrade and merge_source. By default (false), the source patch is applied without subtraction and the target's local differences are preserved by the stored Mutation Protected values; set true to additionally subtract the target's local differences from the source patch. Has no effect on a self merge (merge_source=Self), where subtraction is always disabled. */
51103
+ merge_enable_subtraction?: boolean;
51104
+ /**
51105
+ * @description The specified string is an expression for the purpose of filtering
51106
+ * the list of Mutations returned. The expression syntax was inspired by SQL.
51107
+ * It supports conjunctions using `AND` of relational expressions of the form *attribute*
51108
+ * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
51109
+ * as in the JSON encoding.
51110
+ * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
51111
+ * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
51112
+ * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
51113
+ * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
51114
+ * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
51115
+ * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
51116
+ * UUIDs and boolean attributes support equality and inequality only.
51117
+ * UUID and time literals must be quoted as string literals.
51118
+ * String literals are quoted with single quotes, such as `'string'`.
51119
+ * Time literals use the same form as when serialized as JSON,
51120
+ * such as: `CreatedAt > '2025-02-18T23:16:34'`.
51121
+ * Integer and boolean literals are also supported for attributes of those types.
51122
+ * Arrays support the `?` operator to to match any element of the array,
51123
+ * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
51124
+ * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
51125
+ * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
51126
+ * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
51127
+ * Without the `*` such a reference is an error, since it names no single value to compare.
51128
+ * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
51129
+ * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
51130
+ * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
51131
+ * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
51132
+ * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
51133
+ * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
51134
+ * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
51135
+ * Conjunctions are supported using the `AND` operator.
51136
+ * An example conjunction is:
51137
+ * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
51138
+ *
51139
+ * Supported attributes for filtering on Mutation: ChannelID, CreatedAt, FunctionInvocation.Arguments, FunctionInvocation.Clearance, FunctionInvocation.FunctionName, FunctionInvocation.Guards, FunctionInvocation.WhereResource, FunctionName, HiddenReason, InvocationID, InvocationParams, LinkID, MergeBaseRevisionNum, MergeEndRevisionNum, MergeSourceID, MutationID, MutationNum, OrganizationID, ReplayOutcome, ReplayReason, RestoredRevisionNum, RevisionID, RevisionNum, SpaceID, Subgroup, TriggerID, UnitID, UpdatedAt.
50023
51140
  *
50024
- * Where expression to select destination spaces for cloning units
51141
+ * Selects Mutations of this Unit whose paths the merge must not overwrite, unioned with the Protected values stored on the Unit's MutationSources.
50025
51142
  *
50026
51143
  * The whole string must be query-encoded.
50027
51144
  */
50028
- where_space?: string;
51145
+ where_mutation?: string;
50029
51146
  /**
50030
- * @description UUID of a Filter entity to apply to the Space list.
51147
+ * @description UUID of a Filter entity to apply to the Mutation list.
50031
51148
  *
50032
51149
  * The Filter must be in the same Organization as the user credentials.
50033
51150
  *
50034
- * The Filter's From field must match the entity type being filtered (Space).
51151
+ * The Filter's From field must match the entity type being filtered (Mutation).
50035
51152
  *
50036
51153
  * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
50037
51154
  *
@@ -50039,57 +51156,21 @@ interface operations {
50039
51156
  *
50040
51157
  * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
50041
51158
  */
50042
- filter_space?: string;
50043
- /** @description Allowed values are true and false. Default is false. When true, reports success when an entity already exists and returns the existing entity */
50044
- allow_exists?: string;
50045
- /**
50046
- * @description The specified string is an expression for the purpose of filtering
50047
- * the list of Links returned. The expression syntax was inspired by SQL.
50048
- * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50049
- * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50050
- * as in the JSON encoding.
50051
- * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50052
- * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50053
- * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50054
- * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50055
- * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
50056
- * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
50057
- * UUIDs and boolean attributes support equality and inequality only.
50058
- * UUID and time literals must be quoted as string literals.
50059
- * String literals are quoted with single quotes, such as `'string'`.
50060
- * Time literals use the same form as when serialized as JSON,
50061
- * such as: `CreatedAt > '2025-02-18T23:16:34'`.
50062
- * Integer and boolean literals are also supported for attributes of those types.
50063
- * Arrays support the `?` operator to to match any element of the array,
50064
- * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
50065
- * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
50066
- * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
50067
- * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
50068
- * Without the `*` such a reference is an error, since it names no single value to compare.
50069
- * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
50070
- * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
50071
- * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
50072
- * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
50073
- * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
50074
- * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
50075
- * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
50076
- * Conjunctions are supported using the `AND` operator.
50077
- * An example conjunction is:
50078
- * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
50079
- *
50080
- * Supported attributes for filtering on Link: Annotations, AutoUpdate, BackingUnitID, Bindings, Clearance, CreatedAt, DeleteGates, DisplayName, DownstreamLastMergedRevisionNum, DownstreamPaths, DownstreamSetters, FromUnitID, Guards, Hash, HiddenReason, Labels, LinkID, ManualBindings, MergeEnableSubtraction, OrganizationID, Permissions, Protect, Slug, SpaceID, Squash, Stale, ToSpaceID, ToUnitID, TransformInvocationID, UpdateType, UpdatedAt, UpstreamGetters, UpstreamLastMergedRevisionNum, UpstreamLinkID, UpstreamPaths, UpstreamSpaceID.
50081
- *
50082
- * Where expression to filter outgoing links (links to units outside the cloned set) for copying. If non-empty, matching outgoing links are also copied with FromUnitID retargeted to the cloned unit.
50083
- *
50084
- * The whole string must be query-encoded.
50085
- */
50086
- include_outgoing_links_where?: string;
50087
- /** @description Revision of the upstream Unit to copy. The default is its head, which is what a clone has always taken. Takes the same forms as merge_end and restore -- a revision number, a named revision, 'Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Before:...' -- resolved against the Unit being cloned from, so a bulk clone lands on a different revision of each source Unit. 'Before:ChangeOrder:uuid' is what a promotion uses: it names the state the change starts from, which for a Unit no target has taken yet is its first revision, so the upgrade that follows replays the change into the clone rather than the clone arriving with the change already folded in. Requires upstream_unit_id (or, in bulk, a source Unit to clone). */
50088
- upstream_revision?: string;
50089
- /** @description Also create a MergeUnits Link from each upstream Unit back to its clone, alongside the UpgradeUnit Link a clone always gets. The upgrade Link carries changes from the upstream Unit into the clone; this one carries them the other way, which is what makes a clone usable as a draft: change it, review it, then resolve the Link (resolve=Link:...) on the upstream Unit to merge the change home. A Unit may be the source of several of these -- one per outstanding draft -- so each is named for the clone it takes changes from (syncback-<space>-<unit>) rather than for the Unit they all point at. The Link is created in the upstream Unit's Space, which the caller must be allowed to create Links in. Requires upstream_unit_id (or, in bulk, a source Unit to clone). */
50090
- syncback?: boolean;
50091
- /** @description If true, report what the write would do without doing it: the write runs, including every check it makes, and is then rolled back. The response is the one the write would return, with the entities as they would be written. An entity a dry run creates is given an ID that the real create will not reuse. */
50092
- dry_run?: boolean;
51159
+ filter_mutation?: string;
51160
+ /** @description Tag ID to add to the head revision */
51161
+ tag?: string;
51162
+ /** @description Must match ChangeSetID of affected Units if config Data is changed unless in dry run mode */
51163
+ change_set_id?: string;
51164
+ /** @description ChangeOrder to promote, with upgrade or resolve, or to undo, with restore. The change order fixed the range when it was created -- the interval on each source Unit, marked with its Tags -- so it supplies both ends of the merge and merge_end is refused alongside it. A Unit whose source the change order does not cover is passed over rather than failed, which is what lets a bulk upgrade name a whole Space and take only the Units the change is in. A Unit whose last merged revision is past where the change order starts is an error, since merging anyway would replay what it already has; one that is short of it is handled as prior_revisions says. With resolve a selected Link whose UpdateType the change order does not follow is an error too. The revisions the promotion creates carry the ChangeOrder, and its start Tag is placed on the revision before them and its end Tag on the one it arrives at, so 'restore Before:ChangeOrder:uuid' undoes it whether it landed as one revision or as one per source revision. With restore the change order is being undone rather than promoted: the restore must be 'Before:ChangeOrder:' the same change order, the change order must have an AbortedReason -- undoing a change nobody has said is not coming is a race with whoever is still promoting it -- and a Unit the change order never marked is an error rather than passed over, since naming it says the Unit is part of the undoing. The first restore mints the change order's restore Tag and records it as RestoreTagID; every restore after that marks with the same Tag, which is what RestoredSpaceIDs is read off. A Unit the change order carried nothing for takes the restore Tag on the revision its start and end Tags are already on, and no revision is made. A Unit already carrying the restore Tag has had the change order taken back out of it and is passed over, since undoing one in a Unit happens once as promoting it into one does -- so the revisions a Unit has taken since it was undone are its own work rather than this undoing's to drop. Restoring also advances the merge pointers of the Links of the change order's UpdateType that follow the restored Unit onto the revision the restore made, so a later upgrade does not replay the change that was just taken out; the downstream Units are not restored with it, since each has to be restored and released on its own account. */
51165
+ change_order?: string;
51166
+ /** @description With change_order, when promoting it by upgrade or resolve: what to do for a Unit whose last merged revision of its source is before the revision the change order starts at there -- typically because a Link in the source's Space, such as a TransformPaths Link, wrote revisions after the Unit last merged, and those revisions are not the change order's. Include (the default) merges them first, walking them one source revision at a time even with squash, as revisions that do not carry the change order, and places the change order's start Tag on the revision they leave, so 'restore Before:ChangeOrder:uuid' keeps them. Skip merges only the change order's range, as though the Unit's merge pointer had already been advanced to the change order's start, so what those revisions changed does not reach the Unit. Error refuses, naming the Unit, the Link, and each of those revisions with the operation and Link that made it. All merges them as Include does. A Unit that has already merged past the change order's start is an error whatever this says. Defaults to the change order's PriorRevisions. */
51167
+ prior_revisions?: string;
51168
+ /** @description User-defined category for the Mutation. Must be alphanumeric, at most 64 characters. The prefix 'ConfigHub' is reserved. */
51169
+ subgroup?: string;
51170
+ /** @description Close a ChangeSet a ChangeWorkflow governs although the gates of the workflow's Final do not hold. Applies to a write that clears a Unit's ChangeSetID, which closes its ChangeSet. Requires force_reason, and Edit permission on the ChangeSet, whose CloseOverride records the override. */
51171
+ force_close?: boolean;
51172
+ /** @description Why a ChangeSet's gates are overridden; required with force_close. */
51173
+ force_reason?: string;
50093
51174
  };
50094
51175
  header?: never;
50095
51176
  path?: never;
@@ -50150,7 +51231,7 @@ interface operations {
50150
51231
  "application/json": components["schemas"]["UnitCreateOrUpdateResponse"][];
50151
51232
  };
50152
51233
  };
50153
- /** @description Multi-Status (partial success) */
51234
+ /** @description Multi-Status: Mixed success and failure results */
50154
51235
  207: {
50155
51236
  headers: {
50156
51237
  [name: string]: unknown;
@@ -50204,7 +51285,7 @@ interface operations {
50204
51285
  "application/json": components["schemas"]["StandardErrorResponse"];
50205
51286
  };
50206
51287
  };
50207
- /** @description Unable to create unit(s) due to configuration data problem */
51288
+ /** @description Unable to patch unit(s) due to configuration data problem */
50208
51289
  422: {
50209
51290
  headers: {
50210
51291
  [name: string]: unknown;
@@ -50233,7 +51314,7 @@ interface operations {
50233
51314
  };
50234
51315
  };
50235
51316
  };
50236
- BulkDeleteUnits: {
51317
+ BulkMoveUnits: {
50237
51318
  parameters: {
50238
51319
  query?: {
50239
51320
  /**
@@ -50330,37 +51411,35 @@ interface operations {
50330
51411
  * The whole string must be query-encoded.
50331
51412
  */
50332
51413
  include?: string;
50333
- /** @description Maximum number of Unit entities to act on, in ID order. A request that names limit or continue also stops when it runs short of time, and returns a ConfigHub-Continue header to pass as the continue parameter of the next request; keep sending requests until a response has none. If neither is specified, the request acts on every selected entity. */
50334
- limit?: number;
50335
- /** @description The token from the ConfigHub-Continue header of the previous request, to act on the Unit entities after the last one it acted on. The request's other parameters, except limit, must be the same as those of the request that returned the token. */
50336
- continue?: string;
50337
- /** @description If true, remove the references to the deleted entities from entities the request does not delete, instead of refusing the delete while any remain. References that cannot be removed still refuse it. For a Space, applies to everything the recursive delete removes. */
50338
- detach?: boolean;
51414
+ /** @description Report what the move would do, and what would stop it, without moving anything */
51415
+ dry_run?: boolean;
50339
51416
  };
50340
51417
  header?: never;
50341
51418
  path?: never;
50342
51419
  cookie?: never;
50343
51420
  };
50344
- requestBody?: never;
51421
+ requestBody?: {
51422
+ content: {
51423
+ "application/json": components["schemas"]["UnitMoveRequest"];
51424
+ };
51425
+ };
50345
51426
  responses: {
50346
51427
  /** @description OK */
50347
51428
  200: {
50348
51429
  headers: {
50349
- /** @description The token to pass as the continue parameter of the next request, when there may be more entities after this page. It is absent on the last page. A page can hold fewer entities than the limit, or none, and still have one. */
50350
- "ConfigHub-Continue"?: string;
50351
51430
  [name: string]: unknown;
50352
51431
  };
50353
51432
  content: {
50354
- "application/json": components["schemas"]["DeleteResponse"][];
51433
+ "application/json": components["schemas"]["UnitMoveResponse"][];
50355
51434
  };
50356
51435
  };
50357
- /** @description Multi-Status: Mixed success and failure results */
51436
+ /** @description Multi-Status: nothing was moved, or some Units moved and others did not */
50358
51437
  207: {
50359
51438
  headers: {
50360
51439
  [name: string]: unknown;
50361
51440
  };
50362
51441
  content: {
50363
- "application/json": components["schemas"]["DeleteResponse"][];
51442
+ "application/json": components["schemas"]["UnitMoveResponse"][];
50364
51443
  };
50365
51444
  };
50366
51445
  /** @description Unit request is invalid (Bad Request). */
@@ -50399,7 +51478,7 @@ interface operations {
50399
51478
  "application/json": components["schemas"]["StandardErrorResponse"];
50400
51479
  };
50401
51480
  };
50402
- /** @description Unit is still in use: it has DeleteGates, or other entities still reference it. Or data has changed since last read. */
51481
+ /** @description Unit data conflict. Data has changed since last read. */
50403
51482
  409: {
50404
51483
  headers: {
50405
51484
  [name: string]: unknown;
@@ -50408,24 +51487,6 @@ interface operations {
50408
51487
  "application/json": components["schemas"]["StandardErrorResponse"];
50409
51488
  };
50410
51489
  };
50411
- /** @description Unable to delete entity */
50412
- 422: {
50413
- headers: {
50414
- [name: string]: unknown;
50415
- };
50416
- content: {
50417
- "application/json": components["schemas"]["StandardErrorResponse"];
50418
- };
50419
- };
50420
- /** @description Unable to delete entities due to a inflight operation using one or more of the entities */
50421
- 423: {
50422
- headers: {
50423
- [name: string]: unknown;
50424
- };
50425
- content: {
50426
- "application/json": components["schemas"]["StandardErrorResponse"];
50427
- };
50428
- };
50429
51490
  /** @description Something went wrong while processing Unit. */
50430
51491
  500: {
50431
51492
  headers: {
@@ -50446,7 +51507,7 @@ interface operations {
50446
51507
  };
50447
51508
  };
50448
51509
  };
50449
- BulkPatchUnits: {
51510
+ BulkTagUnits: {
50450
51511
  parameters: {
50451
51512
  query?: {
50452
51513
  /**
@@ -50540,113 +51601,9 @@ interface operations {
50540
51601
  *
50541
51602
  * Supported attributes for Unit are ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID.
50542
51603
  *
50543
- * A write also accepts the parts of its result: ConfigData for the configuration the operation produced, MutationSources for what set each value in it, and Diff for what the operation changed, path by path with the values on both sides. None is a field of a Unit, and each costs something to return, so they are returned only when named. A dry run stores nothing, so this is the only way to see what it would have produced.
50544
- *
50545
- * Supported values: ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID, ConfigData, MutationSources, Diff.
50546
- *
50547
51604
  * The whole string must be query-encoded.
50548
51605
  */
50549
51606
  include?: string;
50550
- /** @description Maximum number of Unit entities to act on, in ID order. A request that names limit or continue also stops when it runs short of time, and returns a ConfigHub-Continue header to pass as the continue parameter of the next request; keep sending requests until a response has none. If neither is specified, the request acts on every selected entity. */
50551
- limit?: number;
50552
- /** @description The token from the ConfigHub-Continue header of the previous request, to act on the Unit entities after the last one it acted on. The request's other parameters, except limit, must be the same as those of the request that returned the token. */
50553
- continue?: string;
50554
- /** @description Dry run mode: return changed unit(s) but don't update configuration data */
50555
- dry_run?: boolean;
50556
- /** @description Record the paths this operation writes as protected local overrides, so a later merge from upstream does not overwrite them. Without it the operation claims nothing: each written path keeps whatever the Unit already has for it, and a path with no history is left unprotected. It only ever adds protection -- re-opening a path is the /protection API (cub unit set-protection --unprotect). Has no effect with restore, which rewinds MutationSources to the restored Revision's stored values wholesale. */
50557
- protect?: boolean;
50558
- /** @description The classes of guarded reason this operation is cleared for, as a JSON Clearance -- a list of {Key, Operator, Values} requirements, where Operator is Exists, In, NotIn, or DoesNotExist. A path whose guards this does not cover is not written, and the withheld change is reported as a Guarded conflict. An absent or empty clearance clears nothing, which only matters for a Unit that has guards. */
50559
- clearance?: string;
50560
- /** @description The guards this operation records on the paths it writes, as a JSON object of guard key to value -- the reasons those paths hold what they hold, so a later operation must be cleared for them before overwriting. The guard analogue of protect: protect claims the paths, this says why. It only ever adds and overwrites the keys it names -- retiring a guard is the /guard API (cub unit set-guard --remove-guard). */
50561
- guards?: string;
50562
- /** @description Merge the range as one rebased diff and record it as one Revision, instead of walking it. By default a merge replays: it takes the source's Revisions in order and, where a Revision records function invocations that can be re-executed, runs them against this Unit rather than rebasing their recorded paths onto it -- so a change lands where this Unit's own structure puts it -- and records each source Revision that has an effect here as a Revision of its own, carrying that Revision's change description, its own conflicts, and one Mutation per source Mutation. Squashing gives up both: the range arrives as a single rebased patch in a single Revision, which is what a merge did before replay existed. Accepted with upgrade, merge_source, and resolve of an UpgradeUnit or MergeUnits Link, and refused elsewhere, since there is no range to walk. A Link can ask for it standingly with its Squash field. */
50563
- squash?: boolean;
50564
- /** @description Upgrade the unit to the latest version of its upstream unit */
50565
- upgrade?: boolean;
50566
- /** @description Restore revision source. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
50567
- restore?: string;
50568
- /** @description Resolve Links from this (downstream) Unit to another (upstream) Unit, propagating what each Link's UpdateType says to propagate. Expects Link:*, Link:<uuid>, or Link:<where expression>. Link:* selects every Link from this Unit that can resolve; a where expression selects among those, evaluated against the Links themselves (e.g. UpdateType = 'MergeUnits'), which is how to name one Link in a bulk operation, where a UUID cannot be. A Link with UpdateType None resolves nothing and is never selected. An AutoUpdate Link may be resolved by hand: it does what the queue would have done, and nothing when the Link is already level with its source. */
50569
- resolve?: string;
50570
- /** @description Merge source unit. Currently it must be a unit ID or 'Self'. */
50571
- merge_source?: string;
50572
- /** @description Merge base revision, which provides the base configuration data of the changes to merge. With merge_source, this is a revision of the merge source unit. With merge_external_source, this is a revision of the unit being updated and overrides the default selection of the latest MergeExternal revision. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
50573
- merge_base?: string;
50574
- /** @description Merge end revision of the merge source, which provides the final configuration of the changes to merge. Also accepted with upgrade and with resolve, where it names how far along the source to take the propagation; the default there is the source's head. Naming a ChangeSet or Tag that ends a change is what leaves a change still being made at the source behind. Supports: Named revisions ('HeadRevisionNum', 'LastReleasedRevisionNum'), direct revision number (e.g., '42'), or entity references ('Tag:uuid', 'ChangeSet:uuid', 'ChangeOrder:uuid', 'Revision:uuid'). Can be prefixed with 'Before:' to select the revision immediately before the specified one (e.g., 'Before:LastReleasedRevisionNum', 'Before:42'). When using Tag or ChangeSet references, the latest revision associated with that entity is selected. 'ChangeOrder:uuid' selects the revision the change order ended at on this Unit and 'Before:ChangeOrder:uuid' the one before it began, which is what undoes a promotion however many revisions it made. */
50575
- merge_end?: string;
50576
- /** @description Identifier of the external source for merge-on-update. When set, computes mutations between the last MergeExternal revision and the provided data, then patches the current unit data with those mutations. */
50577
- merge_external_source?: string;
50578
- /** @description Enable the subtraction (override-preservation) step of upgrade and merge_source. By default (false), the source patch is applied without subtraction and the target's local differences are preserved by the stored Mutation Protected values; set true to additionally subtract the target's local differences from the source patch. Has no effect on a self merge (merge_source=Self), where subtraction is always disabled. */
50579
- merge_enable_subtraction?: boolean;
50580
- /**
50581
- * @description The specified string is an expression for the purpose of filtering
50582
- * the list of Mutations returned. The expression syntax was inspired by SQL.
50583
- * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50584
- * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50585
- * as in the JSON encoding.
50586
- * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50587
- * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50588
- * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50589
- * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50590
- * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
50591
- * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
50592
- * UUIDs and boolean attributes support equality and inequality only.
50593
- * UUID and time literals must be quoted as string literals.
50594
- * String literals are quoted with single quotes, such as `'string'`.
50595
- * Time literals use the same form as when serialized as JSON,
50596
- * such as: `CreatedAt > '2025-02-18T23:16:34'`.
50597
- * Integer and boolean literals are also supported for attributes of those types.
50598
- * Arrays support the `?` operator to to match any element of the array,
50599
- * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
50600
- * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
50601
- * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
50602
- * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
50603
- * Without the `*` such a reference is an error, since it names no single value to compare.
50604
- * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
50605
- * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
50606
- * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
50607
- * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
50608
- * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
50609
- * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
50610
- * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
50611
- * Conjunctions are supported using the `AND` operator.
50612
- * An example conjunction is:
50613
- * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
50614
- *
50615
- * Supported attributes for filtering on Mutation: ChannelID, CreatedAt, FunctionInvocation.Arguments, FunctionInvocation.Clearance, FunctionInvocation.FunctionName, FunctionInvocation.Guards, FunctionInvocation.WhereResource, FunctionName, HiddenReason, InvocationID, InvocationParams, LinkID, MergeBaseRevisionNum, MergeEndRevisionNum, MergeSourceID, MutationID, MutationNum, OrganizationID, ReplayOutcome, ReplayReason, RestoredRevisionNum, RevisionID, RevisionNum, SpaceID, Subgroup, TriggerID, UnitID, UpdatedAt.
50616
- *
50617
- * Selects Mutations of this Unit whose paths the merge must not overwrite, unioned with the Protected values stored on the Unit's MutationSources.
50618
- *
50619
- * The whole string must be query-encoded.
50620
- */
50621
- where_mutation?: string;
50622
- /**
50623
- * @description UUID of a Filter entity to apply to the Mutation list.
50624
- *
50625
- * The Filter must be in the same Organization as the user credentials.
50626
- *
50627
- * The Filter's From field must match the entity type being filtered (Mutation).
50628
- *
50629
- * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
50630
- *
50631
- * The Filter's Where clause will be combined with any explicit 'where' parameter using AND logic.
50632
- *
50633
- * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
50634
- */
50635
- filter_mutation?: string;
50636
- /** @description Tag ID to add to the head revision */
50637
- tag?: string;
50638
- /** @description Must match ChangeSetID of affected Units if config Data is changed unless in dry run mode */
50639
- change_set_id?: string;
50640
- /** @description ChangeOrder to promote, with upgrade or resolve, or to undo, with restore. The change order fixed the range when it was created -- the interval on each source Unit, marked with its Tags -- so it supplies both ends of the merge and merge_end is refused alongside it. A Unit whose source the change order does not cover is passed over rather than failed, which is what lets a bulk upgrade name a whole Space and take only the Units the change is in. A Unit whose last merged revision is past where the change order starts is an error, since merging anyway would replay what it already has; one that is short of it is handled as prior_revisions says. With resolve a selected Link whose UpdateType the change order does not follow is an error too. The revisions the promotion creates carry the ChangeOrder, and its start Tag is placed on the revision before them and its end Tag on the one it arrives at, so 'restore Before:ChangeOrder:uuid' undoes it whether it landed as one revision or as one per source revision. With restore the change order is being undone rather than promoted: the restore must be 'Before:ChangeOrder:' the same change order, the change order must have an AbortedReason -- undoing a change nobody has said is not coming is a race with whoever is still promoting it -- and a Unit the change order never marked is an error rather than passed over, since naming it says the Unit is part of the undoing. The first restore mints the change order's restore Tag and records it as RestoreTagID; every restore after that marks with the same Tag, which is what RestoredSpaceIDs is read off. A Unit the change order carried nothing for takes the restore Tag on the revision its start and end Tags are already on, and no revision is made. A Unit already carrying the restore Tag has had the change order taken back out of it and is passed over, since undoing one in a Unit happens once as promoting it into one does -- so the revisions a Unit has taken since it was undone are its own work rather than this undoing's to drop. Restoring also advances the merge pointers of the Links of the change order's UpdateType that follow the restored Unit onto the revision the restore made, so a later upgrade does not replay the change that was just taken out; the downstream Units are not restored with it, since each has to be restored and released on its own account. */
50641
- change_order?: string;
50642
- /** @description With change_order, when promoting it by upgrade or resolve: what to do for a Unit whose last merged revision of its source is before the revision the change order starts at there -- typically because a Link in the source's Space, such as a TransformPaths Link, wrote revisions after the Unit last merged, and those revisions are not the change order's. Include (the default) merges them first, walking them one source revision at a time even with squash, as revisions that do not carry the change order, and places the change order's start Tag on the revision they leave, so 'restore Before:ChangeOrder:uuid' keeps them. Skip merges only the change order's range, as though the Unit's merge pointer had already been advanced to the change order's start, so what those revisions changed does not reach the Unit. Error refuses, naming the Unit, the Link, and each of those revisions with the operation and Link that made it. All merges them as Include does. A Unit that has already merged past the change order's start is an error whatever this says. Defaults to the change order's PriorRevisions. */
50643
- prior_revisions?: string;
50644
- /** @description User-defined category for the Mutation. Must be alphanumeric, at most 64 characters. The prefix 'ConfigHub' is reserved. */
50645
- subgroup?: string;
50646
- /** @description Close a ChangeSet a ChangeWorkflow governs although the gates of the workflow's Final do not hold. Applies to a write that clears a Unit's ChangeSetID, which closes its ChangeSet. Requires force_reason, and Edit permission on the ChangeSet, whose CloseOverride records the override. */
50647
- force_close?: boolean;
50648
- /** @description Why a ChangeSet's gates are overridden; required with force_close. */
50649
- force_reason?: string;
50650
51607
  };
50651
51608
  header?: never;
50652
51609
  path?: never;
@@ -50654,57 +51611,17 @@ interface operations {
50654
51611
  };
50655
51612
  requestBody?: {
50656
51613
  content: {
50657
- "application/merge-patch+json": {
50658
- /** @description An optional map of Annotation key/value pairs for tools to attach information to entities. */
50659
- Annotations?: {
50660
- [key: string]: string | null;
50661
- } | null;
50662
- /**
50663
- * Format: uuid
50664
- * @description Unique identifier for the ChangeSet to which the current Revision belongs. Optional. Units are not required to belong to ChangeSets.
50665
- */
50666
- ChangeSetID?: string | null;
50667
- /** @description An optional set of gates that, if any is present, will block deletion */
50668
- DeleteGates?: {
50669
- [key: string]: boolean | null;
50670
- } | null;
50671
- /** @description An optional set of gates that, if any is present, will block destroy operations */
50672
- DestroyGates?: {
50673
- [key: string]: boolean | null;
50674
- } | null;
50675
- /** @description Friendly name for the entity. */
50676
- DisplayName?: string | null;
50677
- /** @description The reason the entity is hidden, if it is. A hidden entity is left out of List and Search results, and of what bulk operations act on, unless the include_hidden parameter names its reason or is *, or the where parameter names the entity by Slug or ID. ConfigHub/YAML Units are created hidden with the reason BackingUnit unless given another. */
50678
- HiddenReason?: string | null;
50679
- /** @description An optional map of Label key/value pairs to specify identifying attributes of entities for the purpose of grouping and filtering them. */
50680
- Labels?: {
50681
- [key: string]: string | null;
50682
- } | null;
50683
- /** @description LastChangeDescription is a human-readable description of the last change. This description is copied to the new Revision when the Data is changed. */
50684
- LastChangeDescription?: string | null;
50685
- Permissions?: {
50686
- [key: string]: Record<string, never> | null;
50687
- } | null;
50688
- /** @description Unique URL-safe identifier for the entity. */
50689
- Slug?: string | null;
50690
- /** @description ToolchainType specifies the type of toolchain for this unit. Possible values include "Kubernetes/YAML", "AppConfig/Properties", "AppConfig/YAML", "AppConfig/TOML", "AppConfig/INI", "AppConfig/JSON", "AppConfig/Env", "AppConfig/Text", "ConfigHub/YAML". */
50691
- ToolchainType?: string | null;
50692
- Unreleasable?: boolean | null;
50693
- /** @description An entity-specific sequence number used for optimistic concurrency control. The value read must be sent in calls to Update. */
50694
- Version?: number | null;
50695
- };
51614
+ "application/json": components["schemas"]["UnitTagRequest"];
50696
51615
  };
50697
51616
  };
50698
51617
  responses: {
50699
51618
  /** @description OK */
50700
51619
  200: {
50701
51620
  headers: {
50702
- /** @description The token to pass as the continue parameter of the next request, when there may be more entities after this page. It is absent on the last page. A page can hold fewer entities than the limit, or none, and still have one. */
50703
- "ConfigHub-Continue"?: string;
50704
51621
  [name: string]: unknown;
50705
51622
  };
50706
51623
  content: {
50707
- "application/json": components["schemas"]["UnitCreateOrUpdateResponse"][];
51624
+ "application/json": components["schemas"]["UnitTagResponse"][];
50708
51625
  };
50709
51626
  };
50710
51627
  /** @description Multi-Status: Mixed success and failure results */
@@ -50713,7 +51630,7 @@ interface operations {
50713
51630
  [name: string]: unknown;
50714
51631
  };
50715
51632
  content: {
50716
- "application/json": components["schemas"]["UnitCreateOrUpdateResponse"][];
51633
+ "application/json": components["schemas"]["UnitTagResponse"][];
50717
51634
  };
50718
51635
  };
50719
51636
  /** @description Unit request is invalid (Bad Request). */
@@ -50761,7 +51678,7 @@ interface operations {
50761
51678
  "application/json": components["schemas"]["StandardErrorResponse"];
50762
51679
  };
50763
51680
  };
50764
- /** @description Unable to patch unit(s) due to configuration data problem */
51681
+ /** @description Moving a change order's release tag to a Revision a release of the change could not deliver: before its end tag or the last released Revision, with validation errors, or in a Space where a release has been published at it */
50765
51682
  422: {
50766
51683
  headers: {
50767
51684
  [name: string]: unknown;
@@ -50790,7 +51707,7 @@ interface operations {
50790
51707
  };
50791
51708
  };
50792
51709
  };
50793
- BulkMoveUnits: {
51710
+ SearchUnitBlame: {
50794
51711
  parameters: {
50795
51712
  query?: {
50796
51713
  /**
@@ -50867,6 +51784,14 @@ interface operations {
50867
51784
  * The whole string must be query-encoded.
50868
51785
  */
50869
51786
  contains?: string;
51787
+ /**
51788
+ * @description Only return Unit entities on which the caller has this permission, as well as View, which every entity listed needs.
51789
+ *
51790
+ * A list made to choose an entity to act on can name the permission the action needs, such as Edit to change it or Use to refer to it from another entity, so that it leaves out the entities the action would be refused on.
51791
+ *
51792
+ * Supported values: Manage, Edit, Use, View, Approve, TargetEdit, TargetView.
51793
+ */
51794
+ where_permission?: PathsUnit_blameGetParametersQueryWhere_permission;
50870
51795
  /**
50871
51796
  * @description Hidden Unit entities, those with a HiddenReason, are left out of the results, or of what a bulk operation acts on, unless this names their HiddenReason.
50872
51797
  *
@@ -50877,236 +51802,76 @@ interface operations {
50877
51802
  * ConfigHub/YAML Units, which hold the configuration of entities, are hidden with the HiddenReason `BackingUnit`.
50878
51803
  */
50879
51804
  include_hidden?: string;
51805
+ /** @description UUID of a View of Unit. Its Filter selects the Units as the filter parameter does, so the two may not both be specified. */
51806
+ view?: string;
51807
+ /** @description Maximum number of Units to return the blame of; 50 when not given, and larger values are rejected with 400. When there may be more, the response has a ConfigHub-Continue header to pass as the continue parameter of the next request. */
51808
+ limit?: number;
50880
51809
  /**
50881
- * @description Include clause for expanding related entities in the response for Unit.
50882
- * The attribute names are case-sensitive, PascalCase, and
50883
- * expected in a comma-separated list format as in the JSON encoding.
50884
- *
50885
- * Supported attributes for Unit are ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID.
50886
- *
50887
- * The whole string must be query-encoded.
50888
- */
50889
- include?: string;
50890
- /** @description Report what the move would do, and what would stop it, without moving anything */
50891
- dry_run?: boolean;
50892
- };
50893
- header?: never;
50894
- path?: never;
50895
- cookie?: never;
50896
- };
50897
- requestBody?: {
50898
- content: {
50899
- "application/json": components["schemas"]["UnitMoveRequest"];
50900
- };
50901
- };
50902
- responses: {
50903
- /** @description OK */
50904
- 200: {
50905
- headers: {
50906
- [name: string]: unknown;
50907
- };
50908
- content: {
50909
- "application/json": components["schemas"]["UnitMoveResponse"][];
50910
- };
50911
- };
50912
- /** @description Multi-Status: nothing was moved, or some Units moved and others did not */
50913
- 207: {
50914
- headers: {
50915
- [name: string]: unknown;
50916
- };
50917
- content: {
50918
- "application/json": components["schemas"]["UnitMoveResponse"][];
50919
- };
50920
- };
50921
- /** @description Unit request is invalid (Bad Request). */
50922
- 400: {
50923
- headers: {
50924
- [name: string]: unknown;
50925
- };
50926
- content: {
50927
- "application/json": components["schemas"]["StandardErrorResponse"];
50928
- };
50929
- };
50930
- /** @description Unauthorized access. */
50931
- 401: {
50932
- headers: {
50933
- [name: string]: unknown;
50934
- };
50935
- content: {
50936
- "application/json": components["schemas"]["StandardErrorResponse"];
50937
- };
50938
- };
50939
- /** @description Forbidden access. */
50940
- 403: {
50941
- headers: {
50942
- [name: string]: unknown;
50943
- };
50944
- content: {
50945
- "application/json": components["schemas"]["StandardErrorResponse"];
50946
- };
50947
- };
50948
- /** @description Unit not found. */
50949
- 404: {
50950
- headers: {
50951
- [name: string]: unknown;
50952
- };
50953
- content: {
50954
- "application/json": components["schemas"]["StandardErrorResponse"];
50955
- };
50956
- };
50957
- /** @description Unit data conflict. Data has changed since last read. */
50958
- 409: {
50959
- headers: {
50960
- [name: string]: unknown;
50961
- };
50962
- content: {
50963
- "application/json": components["schemas"]["StandardErrorResponse"];
50964
- };
50965
- };
50966
- /** @description Something went wrong while processing Unit. */
50967
- 500: {
50968
- headers: {
50969
- [name: string]: unknown;
50970
- };
50971
- content: {
50972
- "application/json": components["schemas"]["StandardErrorResponse"];
50973
- };
50974
- };
50975
- /** @description Unexpected error. */
50976
- default: {
50977
- headers: {
50978
- [name: string]: unknown;
50979
- };
50980
- content: {
50981
- "application/json": components["schemas"]["StandardErrorResponse"];
50982
- };
50983
- };
50984
- };
50985
- };
50986
- BulkTagUnits: {
50987
- parameters: {
50988
- query?: {
50989
- /**
50990
- * @description The specified string is an expression for the purpose of filtering
50991
- * the list of Units returned. The expression syntax was inspired by SQL.
50992
- * It supports conjunctions using `AND` of relational expressions of the form *attribute*
50993
- * *operator* *attribute_or_literal*. The attribute names are case-sensitive and PascalCase,
50994
- * as in the JSON encoding.
50995
- * Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `NOT LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `~*`, `!~`, `!~*`, `IN`, `NOT IN`.
50996
- * String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards,
50997
- * `ILIKE` for case-insensitive pattern matching, `NOT LIKE` and `!~~` for negated pattern matching.
50998
- * String regex operators: `~` for regex matching, `~*` for case-insensitive regex,
50999
- * `!~` and `!~*` for regex not matching (case-sensitive and insensitive).
51000
- * Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`.
51001
- * UUIDs and boolean attributes support equality and inequality only.
51002
- * UUID and time literals must be quoted as string literals.
51003
- * String literals are quoted with single quotes, such as `'string'`.
51004
- * Time literals use the same form as when serialized as JSON,
51005
- * such as: `CreatedAt > '2025-02-18T23:16:34'`.
51006
- * Integer and boolean literals are also supported for attributes of those types.
51007
- * Arrays support the `?` operator to to match any element of the array,
51008
- * as in `FromLinkID ? '7c61626f-ddbe-41af-93f6-b69f4ab6d308'`.
51009
- * Arrays can perform LEN() to check for length, as in `LEN(FromLinkID) > 0`.
51010
- * An attribute naming a list of other entities can be filtered on their attributes with a `*` segment,
51011
- * as in `FromLink.*.Slug = 'upgrade-app'`, which holds when any element satisfies it.
51012
- * Without the `*` such a reference is an error, since it names no single value to compare.
51013
- * Map support the dot notation to specify a particular map key, as in `Labels.tier = 'Backend'`.
51014
- * Maps support `IS NULL` and `IS NOT NULL` with dot notation to check for key absence or presence,
51015
- * as in `Labels.tier IS NULL` (key doesn't exist) or `Labels.tier IS NOT NULL` (key exists).
51016
- * Comparison results can be tested with `IS TRUE`, `IS FALSE`, `IS NOT TRUE`, and `IS NOT FALSE`.
51017
- * These are useful for nullable columns: `MergeSourceID = '<uuid>' IS NOT FALSE` matches rows where MergeSourceID equals the value OR is NULL.
51018
- * The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses,
51019
- * such as `Slug IN ('slugone', 'slugtwo')` or `Labels.environment IN ('prod', 'staging')`.
51020
- * Conjunctions are supported using the `AND` operator.
51021
- * An example conjunction is:
51022
- * `CreatedAt >= '2025-01-07' AND Slug = 'test' AND Labels.mykey = 'myvalue'`.
51023
- *
51024
- * Supported attributes for filtering on Unit: Annotations, ApplyGates, ApplyWarnings, ChangeSetID, Conflicts, CreatedAt, DataHash, DeleteGates, DestroyGates, DisplayName, FromLinkID, HeadRevisionID, HeadRevisionNum, HeadUnitEventNum, HiddenReason, Labels, LastChangeDescription, LastReleasedRevisionNum, LinkFindings, NeededPaths, OrganizationID, Permissions, ProvidedPaths, Slug, SpaceID, TargetID, ToolchainType, UnitID, Unreleasable, UpdatedAt, UpstreamRevisionNum, UpstreamSpaceID, UpstreamUnitID, ValidationErrors, ValidationResults, ValidationTriggerIDs, ValidationWarnings, ValueTriggerIDs, Values.
51025
- *
51026
- * Finding all units created by cloning can be done using the expression `UpstreamRevisionNum > 0`. Clones of a specific unit can be found by additionally filtering based on `UpstreamUnitID`. Units never released can be found using `LastReleasedRevisionNum = 0`. Units with unreleased changes can be found with `HeadRevisionNum > LastReleasedRevisionNum AND ReleaseTargetID IS NOT NULL AND Unreleasable = false`.
51027
- *
51028
- * The whole string must be query-encoded.
51029
- */
51030
- where?: string;
51031
- /**
51032
- * @description UUID of a Filter entity to apply to the Unit list.
51033
- *
51034
- * The Filter must be in the same Organization as the user credentials.
51035
- *
51036
- * The Filter's From field must match the entity type being filtered (Unit).
51037
- *
51038
- * For Space-resident entities, if the Filter has a FromSpaceID, it must match the operation's SpaceID.
51039
- *
51040
- * The Filter's Where clause will be combined with any explicit 'where' parameter using AND logic.
51041
- *
51042
- * If both 'filter' and 'where' parameters are specified, they are combined with AND logic.
51043
- */
51044
- filter?: string;
51045
- /**
51046
- * @description Free text search that approximately matches the specified string against string fields and map keys/values.
51047
- *
51048
- * The search is case-insensitive and uses pattern matching to find entities containing the text.
51049
- *
51050
- * Searchable string fields include attributes like Slug, DisplayName, and string-typed custom fields.
51810
+ * @description Comma-separated list of fields to sort Unit results by, each in the form 'ASC|DESC:FieldName' or just 'FieldName'.
51051
51811
  *
51052
- * For map fields (like Labels and Annotations), the search matches both map keys and values.
51812
+ * Field names are case-sensitive and PascalCase, as in the JSON encoding. Sort direction defaults to ASC when the 'DIRECTION:' prefix is omitted.
51053
51813
  *
51054
- * The search uses OR logic across all searchable fields, so matching any field will return the entity.
51814
+ * Supported attributes for ordering Unit: ChangeSetID, CreatedAt, DataHash, DisplayName, HeadRevisionID, HeadRevisionNum, HeadUnitEventNum, HiddenReason, LastChangeDescription, LastReleasedRevisionNum, OrganizationID, Slug, SpaceID, ToolchainType, UnitID, Unreleasable, UpdatedAt, UpstreamRevisionNum, UpstreamUnitID.
51055
51815
  *
51056
- * If both 'where' and 'contains' parameters are specified, they are combined with AND logic.
51816
+ * Example: 'DESC:CreatedAt' or 'DisplayName,DESC:CreatedAt'.
51057
51817
  *
51058
- * Searchable fields for Unit include string and map-type attributes from the queryable attributes list.
51818
+ * Results are ordered by the Unit's ID after the fields named, and by the ID alone if none are.
51059
51819
  *
51060
51820
  * The whole string must be query-encoded.
51061
51821
  */
51062
- contains?: string;
51822
+ order_by?: string;
51063
51823
  /**
51064
- * @description Hidden Unit entities, those with a HiddenReason, are left out of the results, or of what a bulk operation acts on, unless this names their HiddenReason.
51065
- *
51066
- * It is a comma-separated list of HiddenReasons, or `*` for all of them.
51824
+ * @description The token from the ConfigHub-Continue header of the previous page, to return the Unit entities after it.
51067
51825
  *
51068
- * A where clause naming the entities, by their Slug or ID with `=` or `IN`, or naming HiddenReason at all, also returns hidden entities it selects.
51826
+ * The request's other parameters, except limit, must be the same as those of the request that returned the token.
51069
51827
  *
51070
- * ConfigHub/YAML Units, which hold the configuration of entities, are hidden with the HiddenReason `BackingUnit`.
51828
+ * Keep reading until a response has no such header: a page can hold fewer entities than the limit, or none, and still be followed by more.
51071
51829
  */
51072
- include_hidden?: string;
51830
+ continue?: string;
51831
+ /** @description Resource type: Resource type to match for the desired ToolchainType, for example apps/v1/Deployment */
51832
+ resource_type?: string;
51833
+ /** @description Where data: The specified string is an expression for the purpose of evaluating whether the configuration data matches the filter. It supports conjunctions using `AND` of relational expressions of the form *path* *operator* *literal*. The path specifications are dot-separated, for both map fields and array indices, as in `spec.template.spec.containers.0.image = 'ghcr.io/headlamp-k8s/headlamp:latest' AND spec.replicas > 1`. Path expressions support `*` for wildcard array or map segments and `?key=value` syntax for associative matches of array elements containing objects with a `key` attribute. Strings support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `LIKE`, `ILIKE`, `~~`, `!~~`, `~`, `!~`, `~*`, `!~*`, `IN`, `NOT IN`. String pattern operators: `LIKE` and `~~` for pattern matching with `%` and `_` wildcards, `ILIKE` for case-insensitive pattern matching, `!~~` for NOT LIKE. String regex operators: `~` for regex matching, `~*` for case-insensitive regex, `!~` and `!~*` for regex not matching (case-sensitive and insensitive). Integers support the following operators: `<`, `>`, `<=`, `>=`, `=`, `!=`, `IN`, `NOT IN`. Boolean values support equality and inequality only. The `IN` and `NOT IN` operators accept a comma-separated list of values in parentheses, such as `spec.template.spec.containers.0.image#reference IN (':latest', ':arm64-latest')`. The syntax `.|` splits the path: the left side selects, and the right side is a property of what was selected. On the right side of a `.|`, and only there, `!=` is true when the property is absent: `spec.containers.*.|image != 'nginx'` selects the containers and asks that none of their images be nginx, which a container with no image satisfies. Everywhere else a path that is not present is not a match, `!=` included. String literals are quoted with single quotes, such as `'string'`. Integer and boolean literals are also supported for attributes of those types. The whole string must be query-encoded. */
51834
+ where_data?: string;
51835
+ /** @description Which engine answers where_data and resource_type: `sql` (the default) evaluates the expression against the stored resource projection in a single query, falling back to the function engine for the expressions it cannot translate; `function` invokes the where-filter function on each candidate Unit, reading every one's configuration; `shadow` runs both, answers with `function`, and logs any disagreement. Temporary: `function` is the escape hatch for one release, after which this parameter goes away. */
51836
+ where_data_engine?: string;
51837
+ /** @description Where expression to match Triggers. Matched triggers are invoked on each unit to filter by validation results. Use with triggers_passed to control whether passing or failing units are returned (default: failing). */
51838
+ where_trigger?: string;
51839
+ /** @description Filter UUID (with From=Trigger). The filter's matching triggers are invoked on units to filter by validation results. Can be combined with where_trigger. */
51840
+ trigger_filter?: string;
51841
+ /** @description When true, return units that pass trigger validation; when false (default), return units that fail. Only applies when where_trigger or trigger_filter is specified. */
51842
+ triggers_passed?: boolean;
51843
+ /** @description Only the fields whose path contains this substring. */
51844
+ path?: string;
51845
+ /** @description Only the fields of this resource, named as <type>/<name> or <name>; a substring of either matches. */
51846
+ resource?: string;
51073
51847
  /**
51074
- * @description Include clause for expanding related entities in the response for Unit.
51075
- * The attribute names are case-sensitive, PascalCase, and
51076
- * expected in a comma-separated list format as in the JSON encoding.
51077
- *
51078
- * Supported attributes for Unit are ChangeSetID, FromLinkID, HeadMutationNum, HeadRevisionNum, LastReleasedRevisionNum, OrganizationID, Permissions, SpaceID, TargetID, UnitEventID, UpstreamSpaceID, UpstreamUnitID.
51848
+ * @description Only the fields with at least one of these flags, comma-separated. Conflict,Absent,Finding,ValidationError,ValidationWarning selects the fields that need attention.
51079
51849
  *
51080
- * The whole string must be query-encoded.
51850
+ * Supported values: Protected, Guarded, Conflict, Absent, Finding, ValidationError, ValidationWarning, Upgraded, SetByLink, SetByTrigger, ChangeOrder, Unreleased, Needed, Provided.
51081
51851
  */
51082
- include?: string;
51852
+ flags?: string;
51853
+ /** @description Follow each merge and Link resolve into the unit it took the value from, to where the value was set. Default true; false reports each unit's own record, which names the upstream unit without reading it. */
51854
+ upstream?: boolean;
51855
+ /** @description How many upstream units to follow before stopping. */
51856
+ upstream_depth?: number;
51857
+ /** @description Include the $comment$ pseudo-fields that carry YAML comments. */
51858
+ include_comments?: boolean;
51083
51859
  };
51084
51860
  header?: never;
51085
51861
  path?: never;
51086
51862
  cookie?: never;
51087
51863
  };
51088
- requestBody?: {
51089
- content: {
51090
- "application/json": components["schemas"]["UnitTagRequest"];
51091
- };
51092
- };
51864
+ requestBody?: never;
51093
51865
  responses: {
51094
51866
  /** @description OK */
51095
51867
  200: {
51096
51868
  headers: {
51869
+ /** @description The token to pass as the continue parameter of the next request, when there may be more entities after this page. It is absent on the last page. A page can hold fewer entities than the limit, or none, and still have one. */
51870
+ "ConfigHub-Continue"?: string;
51097
51871
  [name: string]: unknown;
51098
51872
  };
51099
51873
  content: {
51100
- "application/json": components["schemas"]["UnitTagResponse"][];
51101
- };
51102
- };
51103
- /** @description Multi-Status: Mixed success and failure results */
51104
- 207: {
51105
- headers: {
51106
- [name: string]: unknown;
51107
- };
51108
- content: {
51109
- "application/json": components["schemas"]["UnitTagResponse"][];
51874
+ "application/json": components["schemas"]["UnitBlame"][];
51110
51875
  };
51111
51876
  };
51112
51877
  /** @description Unit request is invalid (Bad Request). */
@@ -51145,24 +51910,6 @@ interface operations {
51145
51910
  "application/json": components["schemas"]["StandardErrorResponse"];
51146
51911
  };
51147
51912
  };
51148
- /** @description Unit data conflict. Data has changed since last read. */
51149
- 409: {
51150
- headers: {
51151
- [name: string]: unknown;
51152
- };
51153
- content: {
51154
- "application/json": components["schemas"]["StandardErrorResponse"];
51155
- };
51156
- };
51157
- /** @description Moving a change order's release tag to a Revision a release of the change could not deliver: before its end tag or the last released Revision, with validation errors, or in a Space where a release has been published at it */
51158
- 422: {
51159
- headers: {
51160
- [name: string]: unknown;
51161
- };
51162
- content: {
51163
- "application/json": components["schemas"]["StandardErrorResponse"];
51164
- };
51165
- };
51166
51913
  /** @description Something went wrong while processing Unit. */
51167
51914
  500: {
51168
51915
  headers: {
@@ -54035,6 +54782,15 @@ declare enum PathsUnitGetParametersQueryWhere_permission {
54035
54782
  TargetEdit = "TargetEdit",
54036
54783
  TargetView = "TargetView"
54037
54784
  }
54785
+ declare enum PathsUnit_blameGetParametersQueryWhere_permission {
54786
+ Manage = "Manage",
54787
+ Edit = "Edit",
54788
+ Use = "Use",
54789
+ View = "View",
54790
+ Approve = "Approve",
54791
+ TargetEdit = "TargetEdit",
54792
+ TargetView = "TargetView"
54793
+ }
54038
54794
  declare enum PathsUnit_dataGetParametersQueryWhere_permission {
54039
54795
  Manage = "Manage",
54040
54796
  Edit = "Edit",