@to11ai/sdk 2.1.0-rc → 2.1.0-rc.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.
@@ -89,6 +89,18 @@ export type GoneError = {
89
89
  success: false;
90
90
  };
91
91
 
92
+ export type ImportPromptVersionInput = {
93
+ changelog?: string | null;
94
+ files: Array<{
95
+ content: string;
96
+ contentType?: 'text/markdown' | 'text/plain' | null;
97
+ filename: string;
98
+ id?: string | null;
99
+ }>;
100
+ format?: 'skill' | null;
101
+ kind?: 'skill' | null;
102
+ };
103
+
92
104
  export type InternalServerError = {
93
105
  _tag: 'InternalServerError';
94
106
  code: number;
@@ -160,6 +172,7 @@ export type PrincipalApiKeyContextInvariant = {
160
172
  keyFingerprint: string;
161
173
  keyId: string;
162
174
  orgId: string | null;
175
+ orgSlug?: string | null;
163
176
  projectId: string | null;
164
177
  scopes: Array<string>;
165
178
  workspaceId: string | null;
@@ -221,6 +234,7 @@ export type Prompt = {
221
234
  createdByUserId: string;
222
235
  description: string | null;
223
236
  id: string;
237
+ kind: 'chat' | 'skill';
224
238
  name: string;
225
239
  projectId: string;
226
240
  slug: string;
@@ -250,31 +264,13 @@ export type PromptLabelPointer = {
250
264
  versionId: string;
251
265
  };
252
266
 
253
- export type PromptRelease = {
254
- activeFrom: string | null;
255
- activeTo: string | null;
256
- actorId: string;
257
- actorType: 'user' | 'api_key' | 'worker';
258
- assignmentSalt: string | null;
259
- changeKind: 'release_initial' | 'release_promoted' | 'release_rolled_back' | 'release_weight_changed';
260
- createdAt: string;
261
- envSlug: string;
262
- environmentId: string;
263
- id: string;
264
- priorReleaseId: string | null;
265
- promptId: string;
266
- reason: string;
267
- strategy: 'single' | 'weighted';
268
- versionId: string;
269
- };
270
-
271
267
  export type PromptVersion = {
272
268
  changelog: string | null;
273
269
  createdAt: string;
274
270
  createdByDisplayName: string | null;
275
271
  createdByImage: string | null;
276
272
  createdByUserId: string;
277
- format: 'text' | 'chat';
273
+ format: 'text' | 'chat' | 'skill';
278
274
  id: string;
279
275
  modelConfig: unknown;
280
276
  promptId: string;
@@ -298,6 +294,35 @@ export type RenderedChatPrompt = {
298
294
 
299
295
  export type RenderedPrompt = RenderedTextPrompt | RenderedChatPrompt;
300
296
 
297
+ export type RenderedSkill = {
298
+ contentHash: string;
299
+ files: Array<RenderedSkillFile>;
300
+ format: 'skill';
301
+ label: string;
302
+ promptId: string;
303
+ releaseId: string;
304
+ releasedAt?: string | null;
305
+ releasedByDisplayName?: string | null | null;
306
+ version: number;
307
+ versionId: string;
308
+ };
309
+
310
+ export type RenderedSkillFile = {
311
+ content: string;
312
+ contentType: 'text/markdown' | 'text/plain';
313
+ filename: string;
314
+ id: string;
315
+ };
316
+
317
+ export type RenderedSkillVersion = {
318
+ contentHash: string;
319
+ files: Array<RenderedSkillFile>;
320
+ format: 'skill';
321
+ promptId: string;
322
+ version: number;
323
+ versionId: string;
324
+ };
325
+
301
326
  export type RenderedTextMessage = {
302
327
  content: string;
303
328
  role: 'system' | 'user' | 'developer';
@@ -314,6 +339,12 @@ export type RenderedToolMessage = {
314
339
  toolCallId: string;
315
340
  };
316
341
 
342
+ export type ResolvedProjectName = {
343
+ organizationId: string;
344
+ projectId: string;
345
+ workspaceId: string;
346
+ };
347
+
317
348
  export type ResolvedPrompt = {
318
349
  blockRenderRecord?: {
319
350
  [key: string]: 'rendered' | 'dimmed';
@@ -324,12 +355,10 @@ export type ResolvedPrompt = {
324
355
  promptId: string;
325
356
  releaseId: string;
326
357
  rendered: RenderedPrompt;
327
- subjectHash?: string | null;
328
358
  toolChoice?: 'auto' | 'none' | 'required' | {
329
359
  name: string;
330
360
  } | null;
331
361
  tools?: Array<ResolvedToolDefinition> | null;
332
- variantName?: string | null;
333
362
  version: number;
334
363
  versionId: string;
335
364
  };
@@ -419,7 +448,8 @@ export type RuleStep = {
419
448
  };
420
449
 
421
450
  export type RuleTarget = {
422
- modelId: string;
451
+ modelId?: string | null;
452
+ modelName?: string | null;
423
453
  params?: {
424
454
  [key: string]: unknown;
425
455
  } | null;
@@ -3488,8 +3518,9 @@ export type IngestTokenExchangeIngestTokenResponses = {
3488
3518
  200: {
3489
3519
  code: number;
3490
3520
  data: {
3491
- apiKeyId: string;
3521
+ apiKeyId?: string | null;
3492
3522
  expiresAt: string;
3523
+ principalId: string;
3493
3524
  projectId: string;
3494
3525
  scopeClass: 'project' | 'org';
3495
3526
  scopes: Array<string>;
@@ -3823,114 +3854,6 @@ export type OrganizationsGetOrganizationInvitationDetailsResponses = {
3823
3854
 
3824
3855
  export type OrganizationsGetOrganizationInvitationDetailsResponse = OrganizationsGetOrganizationInvitationDetailsResponses[keyof OrganizationsGetOrganizationInvitationDetailsResponses];
3825
3856
 
3826
- export type ApiKeysListApiKeysSuperData = {
3827
- body?: never;
3828
- path?: never;
3829
- query?: {
3830
- page?: number | null;
3831
- limit?: number | null;
3832
- };
3833
- url: '/v1/keys';
3834
- };
3835
-
3836
- export type ApiKeysListApiKeysSuperErrors = {
3837
- /**
3838
- * BadRequestError
3839
- */
3840
- 400: BadRequestError;
3841
- /**
3842
- * UnauthorizedError
3843
- */
3844
- 401: UnauthorizedError;
3845
- /**
3846
- * ForbiddenError
3847
- */
3848
- 403: ForbiddenError;
3849
- /**
3850
- * NotFoundError
3851
- */
3852
- 404: NotFoundError;
3853
- /**
3854
- * ConflictError
3855
- */
3856
- 409: ConflictError;
3857
- /**
3858
- * GoneError
3859
- */
3860
- 410: GoneError;
3861
- /**
3862
- * ContentTooLargeError
3863
- */
3864
- 413: ContentTooLargeError;
3865
- /**
3866
- * MisdirectedRequestError
3867
- */
3868
- 421: MisdirectedRequestError;
3869
- /**
3870
- * UnprocessableEntityError
3871
- */
3872
- 422: UnprocessableEntityError;
3873
- /**
3874
- * TooManyRequestsError
3875
- */
3876
- 429: TooManyRequestsError;
3877
- /**
3878
- * InternalServerError
3879
- */
3880
- 500: InternalServerError;
3881
- /**
3882
- * ServiceUnavailableError
3883
- */
3884
- 503: ServiceUnavailableError;
3885
- };
3886
-
3887
- export type ApiKeysListApiKeysSuperError = ApiKeysListApiKeysSuperErrors[keyof ApiKeysListApiKeysSuperErrors];
3888
-
3889
- export type ApiKeysListApiKeysSuperResponses = {
3890
- /**
3891
- * Success
3892
- */
3893
- 200: {
3894
- code: number;
3895
- data: Array<{
3896
- createdAt: string;
3897
- environment: 'live' | 'test';
3898
- expiresAt: string;
3899
- id: string;
3900
- key: string;
3901
- orgId: string | null;
3902
- projectId: string | null;
3903
- revokedAt: string | null;
3904
- scopes: Array<string>;
3905
- }> | null;
3906
- error: {
3907
- code: string;
3908
- details?: unknown | null;
3909
- message: string;
3910
- rowErrors?: Array<{
3911
- code: string;
3912
- message: string;
3913
- path: Array<string | number>;
3914
- }> | null;
3915
- } | null;
3916
- pagination: {
3917
- limit: number;
3918
- page: number;
3919
- total: number;
3920
- totalPages: number;
3921
- } | null;
3922
- sdkBehavior?: {
3923
- flags: {
3924
- [key: string]: unknown;
3925
- };
3926
- v: number;
3927
- } | null;
3928
- success: boolean;
3929
- };
3930
- };
3931
-
3932
- export type ApiKeysListApiKeysSuperResponse = ApiKeysListApiKeysSuperResponses[keyof ApiKeysListApiKeysSuperResponses];
3933
-
3934
3857
  export type ApiKeysCreateApiKeySuperData = {
3935
3858
  body: {
3936
3859
  environment: 'live' | 'test';
@@ -5731,116 +5654,6 @@ export type OrganizationsResendOrganizationInvitationResponses = {
5731
5654
 
5732
5655
  export type OrganizationsResendOrganizationInvitationResponse = OrganizationsResendOrganizationInvitationResponses[keyof OrganizationsResendOrganizationInvitationResponses];
5733
5656
 
5734
- export type ApiKeysListApiKeysOrgData = {
5735
- body?: never;
5736
- path: {
5737
- orgId: string;
5738
- };
5739
- query?: {
5740
- page?: number | null;
5741
- limit?: number | null;
5742
- };
5743
- url: '/v1/orgs/{orgId}/keys';
5744
- };
5745
-
5746
- export type ApiKeysListApiKeysOrgErrors = {
5747
- /**
5748
- * BadRequestError
5749
- */
5750
- 400: BadRequestError;
5751
- /**
5752
- * UnauthorizedError
5753
- */
5754
- 401: UnauthorizedError;
5755
- /**
5756
- * ForbiddenError
5757
- */
5758
- 403: ForbiddenError;
5759
- /**
5760
- * NotFoundError
5761
- */
5762
- 404: NotFoundError;
5763
- /**
5764
- * ConflictError
5765
- */
5766
- 409: ConflictError;
5767
- /**
5768
- * GoneError
5769
- */
5770
- 410: GoneError;
5771
- /**
5772
- * ContentTooLargeError
5773
- */
5774
- 413: ContentTooLargeError;
5775
- /**
5776
- * MisdirectedRequestError
5777
- */
5778
- 421: MisdirectedRequestError;
5779
- /**
5780
- * UnprocessableEntityError
5781
- */
5782
- 422: UnprocessableEntityError;
5783
- /**
5784
- * TooManyRequestsError
5785
- */
5786
- 429: TooManyRequestsError;
5787
- /**
5788
- * InternalServerError
5789
- */
5790
- 500: InternalServerError;
5791
- /**
5792
- * ServiceUnavailableError
5793
- */
5794
- 503: ServiceUnavailableError;
5795
- };
5796
-
5797
- export type ApiKeysListApiKeysOrgError = ApiKeysListApiKeysOrgErrors[keyof ApiKeysListApiKeysOrgErrors];
5798
-
5799
- export type ApiKeysListApiKeysOrgResponses = {
5800
- /**
5801
- * Success
5802
- */
5803
- 200: {
5804
- code: number;
5805
- data: Array<{
5806
- createdAt: string;
5807
- environment: 'live' | 'test';
5808
- expiresAt: string;
5809
- id: string;
5810
- key: string;
5811
- orgId: string | null;
5812
- projectId: string | null;
5813
- revokedAt: string | null;
5814
- scopes: Array<string>;
5815
- }> | null;
5816
- error: {
5817
- code: string;
5818
- details?: unknown | null;
5819
- message: string;
5820
- rowErrors?: Array<{
5821
- code: string;
5822
- message: string;
5823
- path: Array<string | number>;
5824
- }> | null;
5825
- } | null;
5826
- pagination: {
5827
- limit: number;
5828
- page: number;
5829
- total: number;
5830
- totalPages: number;
5831
- } | null;
5832
- sdkBehavior?: {
5833
- flags: {
5834
- [key: string]: unknown;
5835
- };
5836
- v: number;
5837
- } | null;
5838
- success: boolean;
5839
- };
5840
- };
5841
-
5842
- export type ApiKeysListApiKeysOrgResponse = ApiKeysListApiKeysOrgResponses[keyof ApiKeysListApiKeysOrgResponses];
5843
-
5844
5657
  export type ApiKeysCreateApiKeyOrgData = {
5845
5658
  body: {
5846
5659
  environment: 'live' | 'test';
@@ -7188,6 +7001,7 @@ export type ProjectsCreateProjectByOrgResponses = {
7188
7001
  status: 'active' | 'archived' | 'deleted';
7189
7002
  updatedAt: string;
7190
7003
  workspaceId: string;
7004
+ workspaceSlug: string;
7191
7005
  } | null;
7192
7006
  error: {
7193
7007
  code: string;
@@ -10017,16 +9831,18 @@ export type AuthLookupPrincipalsBatchResponses = {
10017
9831
 
10018
9832
  export type AuthLookupPrincipalsBatchResponse = AuthLookupPrincipalsBatchResponses[keyof AuthLookupPrincipalsBatchResponses];
10019
9833
 
10020
- export type ProjectsDeleteProjectData = {
9834
+ export type ProjectsGetProjectByNameData = {
10021
9835
  body?: never;
10022
9836
  path: {
10023
- projectId: string;
9837
+ organization: string;
9838
+ workspace: string;
9839
+ project: string;
10024
9840
  };
10025
9841
  query?: never;
10026
- url: '/v1/projects/{projectId}';
9842
+ url: '/v1/projects/by-name/{organization}/{workspace}/{project}';
10027
9843
  };
10028
9844
 
10029
- export type ProjectsDeleteProjectErrors = {
9845
+ export type ProjectsGetProjectByNameErrors = {
10030
9846
  /**
10031
9847
  * BadRequestError
10032
9848
  */
@@ -10077,15 +9893,112 @@ export type ProjectsDeleteProjectErrors = {
10077
9893
  503: ServiceUnavailableError;
10078
9894
  };
10079
9895
 
10080
- export type ProjectsDeleteProjectError = ProjectsDeleteProjectErrors[keyof ProjectsDeleteProjectErrors];
9896
+ export type ProjectsGetProjectByNameError = ProjectsGetProjectByNameErrors[keyof ProjectsGetProjectByNameErrors];
10081
9897
 
10082
- export type ProjectsDeleteProjectResponses = {
9898
+ export type ProjectsGetProjectByNameResponses = {
10083
9899
  /**
10084
9900
  * Success
10085
9901
  */
10086
9902
  200: {
10087
9903
  code: number;
10088
- data: {
9904
+ data: ResolvedProjectName | null;
9905
+ error: {
9906
+ code: string;
9907
+ details?: unknown | null;
9908
+ message: string;
9909
+ rowErrors?: Array<{
9910
+ code: string;
9911
+ message: string;
9912
+ path: Array<string | number>;
9913
+ }> | null;
9914
+ } | null;
9915
+ pagination: {
9916
+ limit: number;
9917
+ page: number;
9918
+ total: number;
9919
+ totalPages: number;
9920
+ } | null;
9921
+ sdkBehavior?: {
9922
+ flags: {
9923
+ [key: string]: unknown;
9924
+ };
9925
+ v: number;
9926
+ } | null;
9927
+ success: boolean;
9928
+ };
9929
+ };
9930
+
9931
+ export type ProjectsGetProjectByNameResponse = ProjectsGetProjectByNameResponses[keyof ProjectsGetProjectByNameResponses];
9932
+
9933
+ export type ProjectsDeleteProjectData = {
9934
+ body?: never;
9935
+ path: {
9936
+ projectId: string;
9937
+ };
9938
+ query?: never;
9939
+ url: '/v1/projects/{projectId}';
9940
+ };
9941
+
9942
+ export type ProjectsDeleteProjectErrors = {
9943
+ /**
9944
+ * BadRequestError
9945
+ */
9946
+ 400: BadRequestError;
9947
+ /**
9948
+ * UnauthorizedError
9949
+ */
9950
+ 401: UnauthorizedError;
9951
+ /**
9952
+ * ForbiddenError
9953
+ */
9954
+ 403: ForbiddenError;
9955
+ /**
9956
+ * NotFoundError
9957
+ */
9958
+ 404: NotFoundError;
9959
+ /**
9960
+ * ConflictError
9961
+ */
9962
+ 409: ConflictError;
9963
+ /**
9964
+ * GoneError
9965
+ */
9966
+ 410: GoneError;
9967
+ /**
9968
+ * ContentTooLargeError
9969
+ */
9970
+ 413: ContentTooLargeError;
9971
+ /**
9972
+ * MisdirectedRequestError
9973
+ */
9974
+ 421: MisdirectedRequestError;
9975
+ /**
9976
+ * UnprocessableEntityError
9977
+ */
9978
+ 422: UnprocessableEntityError;
9979
+ /**
9980
+ * TooManyRequestsError
9981
+ */
9982
+ 429: TooManyRequestsError;
9983
+ /**
9984
+ * InternalServerError
9985
+ */
9986
+ 500: InternalServerError;
9987
+ /**
9988
+ * ServiceUnavailableError
9989
+ */
9990
+ 503: ServiceUnavailableError;
9991
+ };
9992
+
9993
+ export type ProjectsDeleteProjectError = ProjectsDeleteProjectErrors[keyof ProjectsDeleteProjectErrors];
9994
+
9995
+ export type ProjectsDeleteProjectResponses = {
9996
+ /**
9997
+ * Success
9998
+ */
9999
+ 200: {
10000
+ code: number;
10001
+ data: {
10089
10002
  createdAt: string;
10090
10003
  dataCenterId: string | null;
10091
10004
  id: string;
@@ -10095,6 +10008,7 @@ export type ProjectsDeleteProjectResponses = {
10095
10008
  status: 'active' | 'archived' | 'deleted';
10096
10009
  updatedAt: string;
10097
10010
  workspaceId: string;
10011
+ workspaceSlug: string;
10098
10012
  } | null;
10099
10013
  error: {
10100
10014
  code: string;
@@ -10202,6 +10116,7 @@ export type ProjectsGetProjectResponses = {
10202
10116
  status: 'active' | 'archived' | 'deleted';
10203
10117
  updatedAt: string;
10204
10118
  workspaceId: string;
10119
+ workspaceSlug: string;
10205
10120
  } | null;
10206
10121
  error: {
10207
10122
  code: string;
@@ -10313,6 +10228,7 @@ export type ProjectsUpdateProjectResponses = {
10313
10228
  status: 'active' | 'archived' | 'deleted';
10314
10229
  updatedAt: string;
10315
10230
  workspaceId: string;
10231
+ workspaceSlug: string;
10316
10232
  } | null;
10317
10233
  error: {
10318
10234
  code: string;
@@ -11488,17 +11404,19 @@ export type ProjectEnvironmentsCreateProjectEnvironmentResponses = {
11488
11404
 
11489
11405
  export type ProjectEnvironmentsCreateProjectEnvironmentResponse = ProjectEnvironmentsCreateProjectEnvironmentResponses[keyof ProjectEnvironmentsCreateProjectEnvironmentResponses];
11490
11406
 
11491
- export type PromptsGetPromptEnvPolicyData = {
11407
+ export type SnapshotGetProjectSnapshotAtTimeData = {
11492
11408
  body?: never;
11493
11409
  path: {
11494
11410
  projectId: string;
11495
11411
  environmentId: string;
11496
11412
  };
11497
- query?: never;
11498
- url: '/v1/projects/{projectId}/environments/{environmentId}/prompt-policy';
11413
+ query: {
11414
+ at: string;
11415
+ };
11416
+ url: '/v1/projects/{projectId}/environments/{environmentId}/snapshot';
11499
11417
  };
11500
11418
 
11501
- export type PromptsGetPromptEnvPolicyErrors = {
11419
+ export type SnapshotGetProjectSnapshotAtTimeErrors = {
11502
11420
  /**
11503
11421
  * BadRequestError
11504
11422
  */
@@ -11549,32 +11467,32 @@ export type PromptsGetPromptEnvPolicyErrors = {
11549
11467
  503: ServiceUnavailableError;
11550
11468
  };
11551
11469
 
11552
- export type PromptsGetPromptEnvPolicyError = PromptsGetPromptEnvPolicyErrors[keyof PromptsGetPromptEnvPolicyErrors];
11470
+ export type SnapshotGetProjectSnapshotAtTimeError = SnapshotGetProjectSnapshotAtTimeErrors[keyof SnapshotGetProjectSnapshotAtTimeErrors];
11553
11471
 
11554
- export type PromptsGetPromptEnvPolicyResponses = {
11472
+ export type SnapshotGetProjectSnapshotAtTimeResponses = {
11555
11473
  /**
11556
11474
  * Success
11557
11475
  */
11558
11476
  200: {
11559
11477
  code: number;
11560
11478
  data: {
11561
- policy: {
11562
- createdAt: string;
11563
- createdBy: string;
11564
- envSlug: string;
11565
- environmentId: string;
11566
- id: string;
11567
- minimumDwellTimeHours: number;
11568
- noRollbackInSource: boolean;
11569
- noRollbackLookBackHours: number;
11570
- projectId: string;
11571
- requiredSourceEnvId: string | null;
11572
- requiredSourceEnvSlug: string | null;
11573
- requiresApproval: boolean;
11574
- requiresApprovalSeparationOfDuties: boolean;
11575
- updatedAt: string;
11576
- updatedBy: string;
11577
- } | null;
11479
+ atIso: string;
11480
+ envSlug: string;
11481
+ environmentId: string;
11482
+ projectId: string;
11483
+ providers: Array<{
11484
+ activeFrom: string;
11485
+ activeTo: string | null;
11486
+ configSnapshot: {
11487
+ [key: string]: unknown;
11488
+ };
11489
+ credentialId: string;
11490
+ credentialLabel: string | null;
11491
+ providerDisplayName: string | null;
11492
+ providerId: string;
11493
+ providerSlug: string;
11494
+ timelineId: string;
11495
+ }>;
11578
11496
  } | null;
11579
11497
  error: {
11580
11498
  code: string;
@@ -11602,26 +11520,30 @@ export type PromptsGetPromptEnvPolicyResponses = {
11602
11520
  };
11603
11521
  };
11604
11522
 
11605
- export type PromptsGetPromptEnvPolicyResponse = PromptsGetPromptEnvPolicyResponses[keyof PromptsGetPromptEnvPolicyResponses];
11523
+ export type SnapshotGetProjectSnapshotAtTimeResponse = SnapshotGetProjectSnapshotAtTimeResponses[keyof SnapshotGetProjectSnapshotAtTimeResponses];
11606
11524
 
11607
- export type PromptsUpsertPromptEnvPolicyData = {
11525
+ export type ProjectEnvironmentsUpdateProjectEnvironmentData = {
11608
11526
  body: {
11609
- minimumDwellTimeHours?: number | null;
11610
- noRollbackInSource?: boolean | null;
11611
- noRollbackLookBackHours?: number | null;
11612
- requiredSourceEnvId?: string | null | null;
11527
+ color?: string | null | null;
11528
+ description?: string | null | null;
11529
+ isDefault?: boolean | null;
11530
+ isGatewayFallback?: boolean | null;
11531
+ isPointer?: boolean | null;
11532
+ isProduction?: boolean | null;
11533
+ name?: string | null;
11613
11534
  requiresApproval?: boolean | null;
11614
- requiresApprovalSeparationOfDuties?: boolean | null;
11535
+ slug?: string | null;
11536
+ sortOrder?: number | null;
11615
11537
  };
11616
11538
  path: {
11617
11539
  projectId: string;
11618
- environmentId: string;
11540
+ param: string;
11619
11541
  };
11620
11542
  query?: never;
11621
- url: '/v1/projects/{projectId}/environments/{environmentId}/prompt-policy';
11543
+ url: '/v1/projects/{projectId}/environments/{param}';
11622
11544
  };
11623
11545
 
11624
- export type PromptsUpsertPromptEnvPolicyErrors = {
11546
+ export type ProjectEnvironmentsUpdateProjectEnvironmentErrors = {
11625
11547
  /**
11626
11548
  * BadRequestError
11627
11549
  */
@@ -11672,33 +11594,15 @@ export type PromptsUpsertPromptEnvPolicyErrors = {
11672
11594
  503: ServiceUnavailableError;
11673
11595
  };
11674
11596
 
11675
- export type PromptsUpsertPromptEnvPolicyError = PromptsUpsertPromptEnvPolicyErrors[keyof PromptsUpsertPromptEnvPolicyErrors];
11597
+ export type ProjectEnvironmentsUpdateProjectEnvironmentError = ProjectEnvironmentsUpdateProjectEnvironmentErrors[keyof ProjectEnvironmentsUpdateProjectEnvironmentErrors];
11676
11598
 
11677
- export type PromptsUpsertPromptEnvPolicyResponses = {
11599
+ export type ProjectEnvironmentsUpdateProjectEnvironmentResponses = {
11678
11600
  /**
11679
11601
  * Success
11680
11602
  */
11681
11603
  200: {
11682
11604
  code: number;
11683
- data: {
11684
- policy: {
11685
- createdAt: string;
11686
- createdBy: string;
11687
- envSlug: string;
11688
- environmentId: string;
11689
- id: string;
11690
- minimumDwellTimeHours: number;
11691
- noRollbackInSource: boolean;
11692
- noRollbackLookBackHours: number;
11693
- projectId: string;
11694
- requiredSourceEnvId: string | null;
11695
- requiredSourceEnvSlug: string | null;
11696
- requiresApproval: boolean;
11697
- requiresApprovalSeparationOfDuties: boolean;
11698
- updatedAt: string;
11699
- updatedBy: string;
11700
- } | null;
11701
- } | null;
11605
+ data: ProjectEnvironment | null;
11702
11606
  error: {
11703
11607
  code: string;
11704
11608
  details?: unknown | null;
@@ -11725,21 +11629,19 @@ export type PromptsUpsertPromptEnvPolicyResponses = {
11725
11629
  };
11726
11630
  };
11727
11631
 
11728
- export type PromptsUpsertPromptEnvPolicyResponse = PromptsUpsertPromptEnvPolicyResponses[keyof PromptsUpsertPromptEnvPolicyResponses];
11632
+ export type ProjectEnvironmentsUpdateProjectEnvironmentResponse = ProjectEnvironmentsUpdateProjectEnvironmentResponses[keyof ProjectEnvironmentsUpdateProjectEnvironmentResponses];
11729
11633
 
11730
- export type SnapshotGetProjectSnapshotAtTimeData = {
11634
+ export type ProjectEnvironmentsGetProjectEnvironmentData = {
11731
11635
  body?: never;
11732
11636
  path: {
11733
11637
  projectId: string;
11734
- environmentId: string;
11735
- };
11736
- query: {
11737
- at: string;
11638
+ slug: string;
11738
11639
  };
11739
- url: '/v1/projects/{projectId}/environments/{environmentId}/snapshot';
11640
+ query?: never;
11641
+ url: '/v1/projects/{projectId}/environments/{slug}';
11740
11642
  };
11741
11643
 
11742
- export type SnapshotGetProjectSnapshotAtTimeErrors = {
11644
+ export type ProjectEnvironmentsGetProjectEnvironmentErrors = {
11743
11645
  /**
11744
11646
  * BadRequestError
11745
11647
  */
@@ -11790,33 +11692,15 @@ export type SnapshotGetProjectSnapshotAtTimeErrors = {
11790
11692
  503: ServiceUnavailableError;
11791
11693
  };
11792
11694
 
11793
- export type SnapshotGetProjectSnapshotAtTimeError = SnapshotGetProjectSnapshotAtTimeErrors[keyof SnapshotGetProjectSnapshotAtTimeErrors];
11695
+ export type ProjectEnvironmentsGetProjectEnvironmentError = ProjectEnvironmentsGetProjectEnvironmentErrors[keyof ProjectEnvironmentsGetProjectEnvironmentErrors];
11794
11696
 
11795
- export type SnapshotGetProjectSnapshotAtTimeResponses = {
11697
+ export type ProjectEnvironmentsGetProjectEnvironmentResponses = {
11796
11698
  /**
11797
11699
  * Success
11798
11700
  */
11799
11701
  200: {
11800
11702
  code: number;
11801
- data: {
11802
- atIso: string;
11803
- envSlug: string;
11804
- environmentId: string;
11805
- projectId: string;
11806
- providers: Array<{
11807
- activeFrom: string;
11808
- activeTo: string | null;
11809
- configSnapshot: {
11810
- [key: string]: unknown;
11811
- };
11812
- credentialId: string;
11813
- credentialLabel: string | null;
11814
- providerDisplayName: string | null;
11815
- providerId: string;
11816
- providerSlug: string;
11817
- timelineId: string;
11818
- }>;
11819
- } | null;
11703
+ data: ProjectEnvironment | null;
11820
11704
  error: {
11821
11705
  code: string;
11822
11706
  details?: unknown | null;
@@ -11843,30 +11727,19 @@ export type SnapshotGetProjectSnapshotAtTimeResponses = {
11843
11727
  };
11844
11728
  };
11845
11729
 
11846
- export type SnapshotGetProjectSnapshotAtTimeResponse = SnapshotGetProjectSnapshotAtTimeResponses[keyof SnapshotGetProjectSnapshotAtTimeResponses];
11730
+ export type ProjectEnvironmentsGetProjectEnvironmentResponse = ProjectEnvironmentsGetProjectEnvironmentResponses[keyof ProjectEnvironmentsGetProjectEnvironmentResponses];
11847
11731
 
11848
- export type ProjectEnvironmentsUpdateProjectEnvironmentData = {
11849
- body: {
11850
- color?: string | null | null;
11851
- description?: string | null | null;
11852
- isDefault?: boolean | null;
11853
- isGatewayFallback?: boolean | null;
11854
- isPointer?: boolean | null;
11855
- isProduction?: boolean | null;
11856
- name?: string | null;
11857
- requiresApproval?: boolean | null;
11858
- slug?: string | null;
11859
- sortOrder?: number | null;
11860
- };
11732
+ export type ProjectEnvironmentsArchiveProjectEnvironmentData = {
11733
+ body?: never;
11861
11734
  path: {
11862
11735
  projectId: string;
11863
- param: string;
11736
+ slug: string;
11864
11737
  };
11865
11738
  query?: never;
11866
- url: '/v1/projects/{projectId}/environments/{param}';
11739
+ url: '/v1/projects/{projectId}/environments/{slug}/archive';
11867
11740
  };
11868
11741
 
11869
- export type ProjectEnvironmentsUpdateProjectEnvironmentErrors = {
11742
+ export type ProjectEnvironmentsArchiveProjectEnvironmentErrors = {
11870
11743
  /**
11871
11744
  * BadRequestError
11872
11745
  */
@@ -11917,15 +11790,15 @@ export type ProjectEnvironmentsUpdateProjectEnvironmentErrors = {
11917
11790
  503: ServiceUnavailableError;
11918
11791
  };
11919
11792
 
11920
- export type ProjectEnvironmentsUpdateProjectEnvironmentError = ProjectEnvironmentsUpdateProjectEnvironmentErrors[keyof ProjectEnvironmentsUpdateProjectEnvironmentErrors];
11793
+ export type ProjectEnvironmentsArchiveProjectEnvironmentError = ProjectEnvironmentsArchiveProjectEnvironmentErrors[keyof ProjectEnvironmentsArchiveProjectEnvironmentErrors];
11921
11794
 
11922
- export type ProjectEnvironmentsUpdateProjectEnvironmentResponses = {
11795
+ export type ProjectEnvironmentsArchiveProjectEnvironmentResponses = {
11923
11796
  /**
11924
11797
  * Success
11925
11798
  */
11926
11799
  200: {
11927
11800
  code: number;
11928
- data: ProjectEnvironment | null;
11801
+ data: ArchiveProjectEnvironmentResult | null;
11929
11802
  error: {
11930
11803
  code: string;
11931
11804
  details?: unknown | null;
@@ -11952,19 +11825,19 @@ export type ProjectEnvironmentsUpdateProjectEnvironmentResponses = {
11952
11825
  };
11953
11826
  };
11954
11827
 
11955
- export type ProjectEnvironmentsUpdateProjectEnvironmentResponse = ProjectEnvironmentsUpdateProjectEnvironmentResponses[keyof ProjectEnvironmentsUpdateProjectEnvironmentResponses];
11828
+ export type ProjectEnvironmentsArchiveProjectEnvironmentResponse = ProjectEnvironmentsArchiveProjectEnvironmentResponses[keyof ProjectEnvironmentsArchiveProjectEnvironmentResponses];
11956
11829
 
11957
- export type ProjectEnvironmentsGetProjectEnvironmentData = {
11830
+ export type ProjectEnvironmentsRestoreProjectEnvironmentData = {
11958
11831
  body?: never;
11959
11832
  path: {
11960
11833
  projectId: string;
11961
11834
  slug: string;
11962
11835
  };
11963
11836
  query?: never;
11964
- url: '/v1/projects/{projectId}/environments/{slug}';
11837
+ url: '/v1/projects/{projectId}/environments/{slug}/restore';
11965
11838
  };
11966
11839
 
11967
- export type ProjectEnvironmentsGetProjectEnvironmentErrors = {
11840
+ export type ProjectEnvironmentsRestoreProjectEnvironmentErrors = {
11968
11841
  /**
11969
11842
  * BadRequestError
11970
11843
  */
@@ -12015,9 +11888,9 @@ export type ProjectEnvironmentsGetProjectEnvironmentErrors = {
12015
11888
  503: ServiceUnavailableError;
12016
11889
  };
12017
11890
 
12018
- export type ProjectEnvironmentsGetProjectEnvironmentError = ProjectEnvironmentsGetProjectEnvironmentErrors[keyof ProjectEnvironmentsGetProjectEnvironmentErrors];
11891
+ export type ProjectEnvironmentsRestoreProjectEnvironmentError = ProjectEnvironmentsRestoreProjectEnvironmentErrors[keyof ProjectEnvironmentsRestoreProjectEnvironmentErrors];
12019
11892
 
12020
- export type ProjectEnvironmentsGetProjectEnvironmentResponses = {
11893
+ export type ProjectEnvironmentsRestoreProjectEnvironmentResponses = {
12021
11894
  /**
12022
11895
  * Success
12023
11896
  */
@@ -12050,19 +11923,21 @@ export type ProjectEnvironmentsGetProjectEnvironmentResponses = {
12050
11923
  };
12051
11924
  };
12052
11925
 
12053
- export type ProjectEnvironmentsGetProjectEnvironmentResponse = ProjectEnvironmentsGetProjectEnvironmentResponses[keyof ProjectEnvironmentsGetProjectEnvironmentResponses];
11926
+ export type ProjectEnvironmentsRestoreProjectEnvironmentResponse = ProjectEnvironmentsRestoreProjectEnvironmentResponses[keyof ProjectEnvironmentsRestoreProjectEnvironmentResponses];
12054
11927
 
12055
- export type ProjectEnvironmentsArchiveProjectEnvironmentData = {
11928
+ export type ApiKeysListApiKeysProjectData = {
12056
11929
  body?: never;
12057
11930
  path: {
12058
11931
  projectId: string;
12059
- slug: string;
12060
11932
  };
12061
- query?: never;
12062
- url: '/v1/projects/{projectId}/environments/{slug}/archive';
11933
+ query?: {
11934
+ page?: number | null;
11935
+ limit?: number | null;
11936
+ };
11937
+ url: '/v1/projects/{projectId}/keys';
12063
11938
  };
12064
11939
 
12065
- export type ProjectEnvironmentsArchiveProjectEnvironmentErrors = {
11940
+ export type ApiKeysListApiKeysProjectErrors = {
12066
11941
  /**
12067
11942
  * BadRequestError
12068
11943
  */
@@ -12113,205 +11988,7 @@ export type ProjectEnvironmentsArchiveProjectEnvironmentErrors = {
12113
11988
  503: ServiceUnavailableError;
12114
11989
  };
12115
11990
 
12116
- export type ProjectEnvironmentsArchiveProjectEnvironmentError = ProjectEnvironmentsArchiveProjectEnvironmentErrors[keyof ProjectEnvironmentsArchiveProjectEnvironmentErrors];
12117
-
12118
- export type ProjectEnvironmentsArchiveProjectEnvironmentResponses = {
12119
- /**
12120
- * Success
12121
- */
12122
- 200: {
12123
- code: number;
12124
- data: ArchiveProjectEnvironmentResult | null;
12125
- error: {
12126
- code: string;
12127
- details?: unknown | null;
12128
- message: string;
12129
- rowErrors?: Array<{
12130
- code: string;
12131
- message: string;
12132
- path: Array<string | number>;
12133
- }> | null;
12134
- } | null;
12135
- pagination: {
12136
- limit: number;
12137
- page: number;
12138
- total: number;
12139
- totalPages: number;
12140
- } | null;
12141
- sdkBehavior?: {
12142
- flags: {
12143
- [key: string]: unknown;
12144
- };
12145
- v: number;
12146
- } | null;
12147
- success: boolean;
12148
- };
12149
- };
12150
-
12151
- export type ProjectEnvironmentsArchiveProjectEnvironmentResponse = ProjectEnvironmentsArchiveProjectEnvironmentResponses[keyof ProjectEnvironmentsArchiveProjectEnvironmentResponses];
12152
-
12153
- export type ProjectEnvironmentsRestoreProjectEnvironmentData = {
12154
- body?: never;
12155
- path: {
12156
- projectId: string;
12157
- slug: string;
12158
- };
12159
- query?: never;
12160
- url: '/v1/projects/{projectId}/environments/{slug}/restore';
12161
- };
12162
-
12163
- export type ProjectEnvironmentsRestoreProjectEnvironmentErrors = {
12164
- /**
12165
- * BadRequestError
12166
- */
12167
- 400: BadRequestError;
12168
- /**
12169
- * UnauthorizedError
12170
- */
12171
- 401: UnauthorizedError;
12172
- /**
12173
- * ForbiddenError
12174
- */
12175
- 403: ForbiddenError;
12176
- /**
12177
- * NotFoundError
12178
- */
12179
- 404: NotFoundError;
12180
- /**
12181
- * ConflictError
12182
- */
12183
- 409: ConflictError;
12184
- /**
12185
- * GoneError
12186
- */
12187
- 410: GoneError;
12188
- /**
12189
- * ContentTooLargeError
12190
- */
12191
- 413: ContentTooLargeError;
12192
- /**
12193
- * MisdirectedRequestError
12194
- */
12195
- 421: MisdirectedRequestError;
12196
- /**
12197
- * UnprocessableEntityError
12198
- */
12199
- 422: UnprocessableEntityError;
12200
- /**
12201
- * TooManyRequestsError
12202
- */
12203
- 429: TooManyRequestsError;
12204
- /**
12205
- * InternalServerError
12206
- */
12207
- 500: InternalServerError;
12208
- /**
12209
- * ServiceUnavailableError
12210
- */
12211
- 503: ServiceUnavailableError;
12212
- };
12213
-
12214
- export type ProjectEnvironmentsRestoreProjectEnvironmentError = ProjectEnvironmentsRestoreProjectEnvironmentErrors[keyof ProjectEnvironmentsRestoreProjectEnvironmentErrors];
12215
-
12216
- export type ProjectEnvironmentsRestoreProjectEnvironmentResponses = {
12217
- /**
12218
- * Success
12219
- */
12220
- 200: {
12221
- code: number;
12222
- data: ProjectEnvironment | null;
12223
- error: {
12224
- code: string;
12225
- details?: unknown | null;
12226
- message: string;
12227
- rowErrors?: Array<{
12228
- code: string;
12229
- message: string;
12230
- path: Array<string | number>;
12231
- }> | null;
12232
- } | null;
12233
- pagination: {
12234
- limit: number;
12235
- page: number;
12236
- total: number;
12237
- totalPages: number;
12238
- } | null;
12239
- sdkBehavior?: {
12240
- flags: {
12241
- [key: string]: unknown;
12242
- };
12243
- v: number;
12244
- } | null;
12245
- success: boolean;
12246
- };
12247
- };
12248
-
12249
- export type ProjectEnvironmentsRestoreProjectEnvironmentResponse = ProjectEnvironmentsRestoreProjectEnvironmentResponses[keyof ProjectEnvironmentsRestoreProjectEnvironmentResponses];
12250
-
12251
- export type ApiKeysListApiKeysProjectData = {
12252
- body?: never;
12253
- path: {
12254
- projectId: string;
12255
- };
12256
- query?: {
12257
- page?: number | null;
12258
- limit?: number | null;
12259
- };
12260
- url: '/v1/projects/{projectId}/keys';
12261
- };
12262
-
12263
- export type ApiKeysListApiKeysProjectErrors = {
12264
- /**
12265
- * BadRequestError
12266
- */
12267
- 400: BadRequestError;
12268
- /**
12269
- * UnauthorizedError
12270
- */
12271
- 401: UnauthorizedError;
12272
- /**
12273
- * ForbiddenError
12274
- */
12275
- 403: ForbiddenError;
12276
- /**
12277
- * NotFoundError
12278
- */
12279
- 404: NotFoundError;
12280
- /**
12281
- * ConflictError
12282
- */
12283
- 409: ConflictError;
12284
- /**
12285
- * GoneError
12286
- */
12287
- 410: GoneError;
12288
- /**
12289
- * ContentTooLargeError
12290
- */
12291
- 413: ContentTooLargeError;
12292
- /**
12293
- * MisdirectedRequestError
12294
- */
12295
- 421: MisdirectedRequestError;
12296
- /**
12297
- * UnprocessableEntityError
12298
- */
12299
- 422: UnprocessableEntityError;
12300
- /**
12301
- * TooManyRequestsError
12302
- */
12303
- 429: TooManyRequestsError;
12304
- /**
12305
- * InternalServerError
12306
- */
12307
- 500: InternalServerError;
12308
- /**
12309
- * ServiceUnavailableError
12310
- */
12311
- 503: ServiceUnavailableError;
12312
- };
12313
-
12314
- export type ApiKeysListApiKeysProjectError = ApiKeysListApiKeysProjectErrors[keyof ApiKeysListApiKeysProjectErrors];
11991
+ export type ApiKeysListApiKeysProjectError = ApiKeysListApiKeysProjectErrors[keyof ApiKeysListApiKeysProjectErrors];
12315
11992
 
12316
11993
  export type ApiKeysListApiKeysProjectResponses = {
12317
11994
  /**
@@ -14593,6 +14270,7 @@ export type PromptsListPromptsData = {
14593
14270
  search?: string | null;
14594
14271
  sortDir?: 'asc' | 'desc' | null;
14595
14272
  status?: string | null;
14273
+ kind?: string | null;
14596
14274
  sortBy?: 'createdAt' | 'updatedAt' | 'name' | 'status' | 'latestVersion' | 'environments' | null;
14597
14275
  tags?: string | null;
14598
14276
  environment?: string | null;
@@ -14664,13 +14342,14 @@ export type PromptsListPromptsResponses = {
14664
14342
  createdByUserId: string;
14665
14343
  description: string | null;
14666
14344
  id: string;
14345
+ kind: 'chat' | 'skill';
14667
14346
  labels: Array<{
14668
14347
  label: string;
14669
14348
  version: number | null;
14670
- weighted: {
14349
+ weighted?: {
14671
14350
  split: string;
14672
14351
  variants: number;
14673
- } | null;
14352
+ } | null | null;
14674
14353
  }>;
14675
14354
  lastModifiedAt: string;
14676
14355
  lastModifiedByDisplayName: string | null;
@@ -14716,6 +14395,7 @@ export type PromptsListPromptsResponse = PromptsListPromptsResponses[keyof Promp
14716
14395
  export type PromptsCreatePromptData = {
14717
14396
  body: {
14718
14397
  description?: string | null;
14398
+ kind?: 'chat' | 'skill' | null;
14719
14399
  name: string;
14720
14400
  slug: string;
14721
14401
  tags?: Array<string> | null;
@@ -15003,7 +14683,7 @@ export type PromptsRenderPromptResponses = {
15003
14683
  */
15004
14684
  200: {
15005
14685
  code: number;
15006
- data: ResolvedPrompt | null;
14686
+ data: ResolvedPrompt | RenderedSkill | null;
15007
14687
  error: {
15008
14688
  code: string;
15009
14689
  details?: unknown | null;
@@ -15032,16 +14712,22 @@ export type PromptsRenderPromptResponses = {
15032
14712
 
15033
14713
  export type PromptsRenderPromptResponse = PromptsRenderPromptResponses[keyof PromptsRenderPromptResponses];
15034
14714
 
15035
- export type PromptsGetPromptDirectorySummaryData = {
15036
- body?: never;
14715
+ export type PromptsRenderSkillVersionData = {
14716
+ body: {
14717
+ variables?: {
14718
+ [key: string]: unknown;
14719
+ } | null;
14720
+ };
15037
14721
  path: {
15038
14722
  projectId: string;
14723
+ slug: string;
14724
+ versionNumber: string;
15039
14725
  };
15040
14726
  query?: never;
15041
- url: '/v1/projects/{projectId}/prompts/summary';
14727
+ url: '/v1/projects/{projectId}/prompts/by-slug/{slug}/versions/{versionNumber}/render';
15042
14728
  };
15043
14729
 
15044
- export type PromptsGetPromptDirectorySummaryErrors = {
14730
+ export type PromptsRenderSkillVersionErrors = {
15045
14731
  /**
15046
14732
  * BadRequestError
15047
14733
  */
@@ -15092,33 +14778,15 @@ export type PromptsGetPromptDirectorySummaryErrors = {
15092
14778
  503: ServiceUnavailableError;
15093
14779
  };
15094
14780
 
15095
- export type PromptsGetPromptDirectorySummaryError = PromptsGetPromptDirectorySummaryErrors[keyof PromptsGetPromptDirectorySummaryErrors];
14781
+ export type PromptsRenderSkillVersionError = PromptsRenderSkillVersionErrors[keyof PromptsRenderSkillVersionErrors];
15096
14782
 
15097
- export type PromptsGetPromptDirectorySummaryResponses = {
14783
+ export type PromptsRenderSkillVersionResponses = {
15098
14784
  /**
15099
14785
  * Success
15100
14786
  */
15101
14787
  200: {
15102
14788
  code: number;
15103
- data: {
15104
- activeReleases: {
15105
- count: number;
15106
- environmentCount: number;
15107
- };
15108
- fetches24h: {
15109
- count: number;
15110
- deltaPctVsPrev: number;
15111
- } | null;
15112
- prompts: {
15113
- archived: number;
15114
- published: number;
15115
- total: number;
15116
- };
15117
- rollbacks30d: {
15118
- count: number;
15119
- promotions: number;
15120
- };
15121
- } | null;
14789
+ data: RenderedSkillVersion | null;
15122
14790
  error: {
15123
14791
  code: string;
15124
14792
  details?: unknown | null;
@@ -15145,19 +14813,20 @@ export type PromptsGetPromptDirectorySummaryResponses = {
15145
14813
  };
15146
14814
  };
15147
14815
 
15148
- export type PromptsGetPromptDirectorySummaryResponse = PromptsGetPromptDirectorySummaryResponses[keyof PromptsGetPromptDirectorySummaryResponses];
14816
+ export type PromptsRenderSkillVersionResponse = PromptsRenderSkillVersionResponses[keyof PromptsRenderSkillVersionResponses];
15149
14817
 
15150
- export type PromptsArchivePromptData = {
14818
+ export type PromptsGetPromptDirectorySummaryData = {
15151
14819
  body?: never;
15152
14820
  path: {
15153
14821
  projectId: string;
15154
- promptId: string;
15155
14822
  };
15156
- query?: never;
15157
- url: '/v1/projects/{projectId}/prompts/{promptId}';
14823
+ query?: {
14824
+ kind?: string | null;
14825
+ };
14826
+ url: '/v1/projects/{projectId}/prompts/summary';
15158
14827
  };
15159
14828
 
15160
- export type PromptsArchivePromptErrors = {
14829
+ export type PromptsGetPromptDirectorySummaryErrors = {
15161
14830
  /**
15162
14831
  * BadRequestError
15163
14832
  */
@@ -15208,431 +14877,33 @@ export type PromptsArchivePromptErrors = {
15208
14877
  503: ServiceUnavailableError;
15209
14878
  };
15210
14879
 
15211
- export type PromptsArchivePromptError = PromptsArchivePromptErrors[keyof PromptsArchivePromptErrors];
14880
+ export type PromptsGetPromptDirectorySummaryError = PromptsGetPromptDirectorySummaryErrors[keyof PromptsGetPromptDirectorySummaryErrors];
15212
14881
 
15213
- export type PromptsArchivePromptResponses = {
15214
- /**
15215
- * Success
15216
- */
15217
- 200: {
15218
- code: number;
15219
- data: Prompt | null;
15220
- error: {
15221
- code: string;
15222
- details?: unknown | null;
15223
- message: string;
15224
- rowErrors?: Array<{
15225
- code: string;
15226
- message: string;
15227
- path: Array<string | number>;
15228
- }> | null;
15229
- } | null;
15230
- pagination: {
15231
- limit: number;
15232
- page: number;
15233
- total: number;
15234
- totalPages: number;
15235
- } | null;
15236
- sdkBehavior?: {
15237
- flags: {
15238
- [key: string]: unknown;
15239
- };
15240
- v: number;
15241
- } | null;
15242
- success: boolean;
15243
- };
15244
- };
15245
-
15246
- export type PromptsArchivePromptResponse = PromptsArchivePromptResponses[keyof PromptsArchivePromptResponses];
15247
-
15248
- export type PromptsGetPromptData = {
15249
- body?: never;
15250
- path: {
15251
- projectId: string;
15252
- promptId: string;
15253
- };
15254
- query?: never;
15255
- url: '/v1/projects/{projectId}/prompts/{promptId}';
15256
- };
15257
-
15258
- export type PromptsGetPromptErrors = {
15259
- /**
15260
- * BadRequestError
15261
- */
15262
- 400: BadRequestError;
15263
- /**
15264
- * UnauthorizedError
15265
- */
15266
- 401: UnauthorizedError;
15267
- /**
15268
- * ForbiddenError
15269
- */
15270
- 403: ForbiddenError;
15271
- /**
15272
- * NotFoundError
15273
- */
15274
- 404: NotFoundError;
15275
- /**
15276
- * ConflictError
15277
- */
15278
- 409: ConflictError;
15279
- /**
15280
- * GoneError
15281
- */
15282
- 410: GoneError;
15283
- /**
15284
- * ContentTooLargeError
15285
- */
15286
- 413: ContentTooLargeError;
15287
- /**
15288
- * MisdirectedRequestError
15289
- */
15290
- 421: MisdirectedRequestError;
15291
- /**
15292
- * UnprocessableEntityError
15293
- */
15294
- 422: UnprocessableEntityError;
15295
- /**
15296
- * TooManyRequestsError
15297
- */
15298
- 429: TooManyRequestsError;
15299
- /**
15300
- * InternalServerError
15301
- */
15302
- 500: InternalServerError;
15303
- /**
15304
- * ServiceUnavailableError
15305
- */
15306
- 503: ServiceUnavailableError;
15307
- };
15308
-
15309
- export type PromptsGetPromptError = PromptsGetPromptErrors[keyof PromptsGetPromptErrors];
15310
-
15311
- export type PromptsGetPromptResponses = {
15312
- /**
15313
- * Success
15314
- */
15315
- 200: {
15316
- code: number;
15317
- data: Prompt | null;
15318
- error: {
15319
- code: string;
15320
- details?: unknown | null;
15321
- message: string;
15322
- rowErrors?: Array<{
15323
- code: string;
15324
- message: string;
15325
- path: Array<string | number>;
15326
- }> | null;
15327
- } | null;
15328
- pagination: {
15329
- limit: number;
15330
- page: number;
15331
- total: number;
15332
- totalPages: number;
15333
- } | null;
15334
- sdkBehavior?: {
15335
- flags: {
15336
- [key: string]: unknown;
15337
- };
15338
- v: number;
15339
- } | null;
15340
- success: boolean;
15341
- };
15342
- };
15343
-
15344
- export type PromptsGetPromptResponse = PromptsGetPromptResponses[keyof PromptsGetPromptResponses];
15345
-
15346
- export type PromptsUpdatePromptData = {
15347
- body: {
15348
- description?: string | null | null;
15349
- name?: string | null;
15350
- status?: 'active' | 'archived' | null;
15351
- tags?: Array<string> | null;
15352
- };
15353
- path: {
15354
- projectId: string;
15355
- promptId: string;
15356
- };
15357
- query?: never;
15358
- url: '/v1/projects/{projectId}/prompts/{promptId}';
15359
- };
15360
-
15361
- export type PromptsUpdatePromptErrors = {
15362
- /**
15363
- * BadRequestError
15364
- */
15365
- 400: BadRequestError;
15366
- /**
15367
- * UnauthorizedError
15368
- */
15369
- 401: UnauthorizedError;
15370
- /**
15371
- * ForbiddenError
15372
- */
15373
- 403: ForbiddenError;
15374
- /**
15375
- * NotFoundError
15376
- */
15377
- 404: NotFoundError;
15378
- /**
15379
- * ConflictError
15380
- */
15381
- 409: ConflictError;
15382
- /**
15383
- * GoneError
15384
- */
15385
- 410: GoneError;
15386
- /**
15387
- * ContentTooLargeError
15388
- */
15389
- 413: ContentTooLargeError;
15390
- /**
15391
- * MisdirectedRequestError
15392
- */
15393
- 421: MisdirectedRequestError;
15394
- /**
15395
- * UnprocessableEntityError
15396
- */
15397
- 422: UnprocessableEntityError;
15398
- /**
15399
- * TooManyRequestsError
15400
- */
15401
- 429: TooManyRequestsError;
15402
- /**
15403
- * InternalServerError
15404
- */
15405
- 500: InternalServerError;
15406
- /**
15407
- * ServiceUnavailableError
15408
- */
15409
- 503: ServiceUnavailableError;
15410
- };
15411
-
15412
- export type PromptsUpdatePromptError = PromptsUpdatePromptErrors[keyof PromptsUpdatePromptErrors];
15413
-
15414
- export type PromptsUpdatePromptResponses = {
15415
- /**
15416
- * Success
15417
- */
15418
- 200: {
15419
- code: number;
15420
- data: Prompt | null;
15421
- error: {
15422
- code: string;
15423
- details?: unknown | null;
15424
- message: string;
15425
- rowErrors?: Array<{
15426
- code: string;
15427
- message: string;
15428
- path: Array<string | number>;
15429
- }> | null;
15430
- } | null;
15431
- pagination: {
15432
- limit: number;
15433
- page: number;
15434
- total: number;
15435
- totalPages: number;
15436
- } | null;
15437
- sdkBehavior?: {
15438
- flags: {
15439
- [key: string]: unknown;
15440
- };
15441
- v: number;
15442
- } | null;
15443
- success: boolean;
15444
- };
15445
- };
15446
-
15447
- export type PromptsUpdatePromptResponse = PromptsUpdatePromptResponses[keyof PromptsUpdatePromptResponses];
15448
-
15449
- export type PromptsListPromptLabelEventsByPromptData = {
15450
- body?: never;
15451
- path: {
15452
- projectId: string;
15453
- promptId: string;
15454
- };
15455
- query?: {
15456
- page?: string | null;
15457
- limit?: string | null;
15458
- label?: string | null;
15459
- promptId?: string | null;
15460
- since?: string | null;
15461
- until?: string | null;
15462
- };
15463
- url: '/v1/projects/{projectId}/prompts/{promptId}/label-events';
15464
- };
15465
-
15466
- export type PromptsListPromptLabelEventsByPromptErrors = {
15467
- /**
15468
- * BadRequestError
15469
- */
15470
- 400: BadRequestError;
15471
- /**
15472
- * UnauthorizedError
15473
- */
15474
- 401: UnauthorizedError;
15475
- /**
15476
- * ForbiddenError
15477
- */
15478
- 403: ForbiddenError;
15479
- /**
15480
- * NotFoundError
15481
- */
15482
- 404: NotFoundError;
15483
- /**
15484
- * ConflictError
15485
- */
15486
- 409: ConflictError;
15487
- /**
15488
- * GoneError
15489
- */
15490
- 410: GoneError;
15491
- /**
15492
- * ContentTooLargeError
15493
- */
15494
- 413: ContentTooLargeError;
15495
- /**
15496
- * MisdirectedRequestError
15497
- */
15498
- 421: MisdirectedRequestError;
15499
- /**
15500
- * UnprocessableEntityError
15501
- */
15502
- 422: UnprocessableEntityError;
15503
- /**
15504
- * TooManyRequestsError
15505
- */
15506
- 429: TooManyRequestsError;
15507
- /**
15508
- * InternalServerError
15509
- */
15510
- 500: InternalServerError;
15511
- /**
15512
- * ServiceUnavailableError
15513
- */
15514
- 503: ServiceUnavailableError;
15515
- };
15516
-
15517
- export type PromptsListPromptLabelEventsByPromptError = PromptsListPromptLabelEventsByPromptErrors[keyof PromptsListPromptLabelEventsByPromptErrors];
15518
-
15519
- export type PromptsListPromptLabelEventsByPromptResponses = {
14882
+ export type PromptsGetPromptDirectorySummaryResponses = {
15520
14883
  /**
15521
14884
  * Success
15522
14885
  */
15523
14886
  200: {
15524
14887
  code: number;
15525
14888
  data: {
15526
- items: Array<PromptLabelEvent>;
15527
- pagination: {
15528
- limit: number;
15529
- page: number;
14889
+ activeReleases: {
14890
+ count: number;
14891
+ environmentCount: number;
14892
+ };
14893
+ fetches24h: {
14894
+ count: number;
14895
+ deltaPctVsPrev: number;
14896
+ } | null;
14897
+ prompts: {
14898
+ archived: number;
14899
+ published: number;
15530
14900
  total: number;
15531
- totalPages: number;
15532
14901
  };
15533
- } | null;
15534
- error: {
15535
- code: string;
15536
- details?: unknown | null;
15537
- message: string;
15538
- rowErrors?: Array<{
15539
- code: string;
15540
- message: string;
15541
- path: Array<string | number>;
15542
- }> | null;
15543
- } | null;
15544
- pagination: {
15545
- limit: number;
15546
- page: number;
15547
- total: number;
15548
- totalPages: number;
15549
- } | null;
15550
- sdkBehavior?: {
15551
- flags: {
15552
- [key: string]: unknown;
14902
+ rollbacks30d: {
14903
+ count: number;
14904
+ promotions: number;
15553
14905
  };
15554
- v: number;
15555
14906
  } | null;
15556
- success: boolean;
15557
- };
15558
- };
15559
-
15560
- export type PromptsListPromptLabelEventsByPromptResponse = PromptsListPromptLabelEventsByPromptResponses[keyof PromptsListPromptLabelEventsByPromptResponses];
15561
-
15562
- export type PromptsListPromptLabelsData = {
15563
- body?: never;
15564
- path: {
15565
- projectId: string;
15566
- promptId: string;
15567
- };
15568
- query?: {
15569
- asOf?: string | null;
15570
- page?: number | null;
15571
- limit?: number | null;
15572
- };
15573
- url: '/v1/projects/{projectId}/prompts/{promptId}/labels';
15574
- };
15575
-
15576
- export type PromptsListPromptLabelsErrors = {
15577
- /**
15578
- * BadRequestError
15579
- */
15580
- 400: BadRequestError;
15581
- /**
15582
- * UnauthorizedError
15583
- */
15584
- 401: UnauthorizedError;
15585
- /**
15586
- * ForbiddenError
15587
- */
15588
- 403: ForbiddenError;
15589
- /**
15590
- * NotFoundError
15591
- */
15592
- 404: NotFoundError;
15593
- /**
15594
- * ConflictError
15595
- */
15596
- 409: ConflictError;
15597
- /**
15598
- * GoneError
15599
- */
15600
- 410: GoneError;
15601
- /**
15602
- * ContentTooLargeError
15603
- */
15604
- 413: ContentTooLargeError;
15605
- /**
15606
- * MisdirectedRequestError
15607
- */
15608
- 421: MisdirectedRequestError;
15609
- /**
15610
- * UnprocessableEntityError
15611
- */
15612
- 422: UnprocessableEntityError;
15613
- /**
15614
- * TooManyRequestsError
15615
- */
15616
- 429: TooManyRequestsError;
15617
- /**
15618
- * InternalServerError
15619
- */
15620
- 500: InternalServerError;
15621
- /**
15622
- * ServiceUnavailableError
15623
- */
15624
- 503: ServiceUnavailableError;
15625
- };
15626
-
15627
- export type PromptsListPromptLabelsError = PromptsListPromptLabelsErrors[keyof PromptsListPromptLabelsErrors];
15628
-
15629
- export type PromptsListPromptLabelsResponses = {
15630
- /**
15631
- * Success
15632
- */
15633
- 200: {
15634
- code: number;
15635
- data: Array<PromptLabelPointer> | null;
15636
14907
  error: {
15637
14908
  code: string;
15638
14909
  details?: unknown | null;
@@ -15659,23 +14930,19 @@ export type PromptsListPromptLabelsResponses = {
15659
14930
  };
15660
14931
  };
15661
14932
 
15662
- export type PromptsListPromptLabelsResponse = PromptsListPromptLabelsResponses[keyof PromptsListPromptLabelsResponses];
14933
+ export type PromptsGetPromptDirectorySummaryResponse = PromptsGetPromptDirectorySummaryResponses[keyof PromptsGetPromptDirectorySummaryResponses];
15663
14934
 
15664
- export type PromptsMovePromptLabelData = {
15665
- body: {
15666
- reason: string;
15667
- versionId: string;
15668
- };
14935
+ export type PromptsArchivePromptData = {
14936
+ body?: never;
15669
14937
  path: {
15670
14938
  projectId: string;
15671
14939
  promptId: string;
15672
- label: string;
15673
14940
  };
15674
14941
  query?: never;
15675
- url: '/v1/projects/{projectId}/prompts/{promptId}/labels/{label}';
14942
+ url: '/v1/projects/{projectId}/prompts/{promptId}';
15676
14943
  };
15677
14944
 
15678
- export type PromptsMovePromptLabelErrors = {
14945
+ export type PromptsArchivePromptErrors = {
15679
14946
  /**
15680
14947
  * BadRequestError
15681
14948
  */
@@ -15726,15 +14993,15 @@ export type PromptsMovePromptLabelErrors = {
15726
14993
  503: ServiceUnavailableError;
15727
14994
  };
15728
14995
 
15729
- export type PromptsMovePromptLabelError = PromptsMovePromptLabelErrors[keyof PromptsMovePromptLabelErrors];
14996
+ export type PromptsArchivePromptError = PromptsArchivePromptErrors[keyof PromptsArchivePromptErrors];
15730
14997
 
15731
- export type PromptsMovePromptLabelResponses = {
14998
+ export type PromptsArchivePromptResponses = {
15732
14999
  /**
15733
15000
  * Success
15734
15001
  */
15735
15002
  200: {
15736
15003
  code: number;
15737
- data: PromptLabelPointer | null;
15004
+ data: Prompt | null;
15738
15005
  error: {
15739
15006
  code: string;
15740
15007
  details?: unknown | null;
@@ -15761,27 +15028,19 @@ export type PromptsMovePromptLabelResponses = {
15761
15028
  };
15762
15029
  };
15763
15030
 
15764
- export type PromptsMovePromptLabelResponse = PromptsMovePromptLabelResponses[keyof PromptsMovePromptLabelResponses];
15031
+ export type PromptsArchivePromptResponse = PromptsArchivePromptResponses[keyof PromptsArchivePromptResponses];
15765
15032
 
15766
- export type PromptsListPromptLabelEventsByLabelData = {
15033
+ export type PromptsGetPromptData = {
15767
15034
  body?: never;
15768
15035
  path: {
15769
15036
  projectId: string;
15770
15037
  promptId: string;
15771
- label: string;
15772
- };
15773
- query?: {
15774
- page?: string | null;
15775
- limit?: string | null;
15776
- label?: string | null;
15777
- promptId?: string | null;
15778
- since?: string | null;
15779
- until?: string | null;
15780
15038
  };
15781
- url: '/v1/projects/{projectId}/prompts/{promptId}/labels/{label}/events';
15039
+ query?: never;
15040
+ url: '/v1/projects/{projectId}/prompts/{promptId}';
15782
15041
  };
15783
15042
 
15784
- export type PromptsListPromptLabelEventsByLabelErrors = {
15043
+ export type PromptsGetPromptErrors = {
15785
15044
  /**
15786
15045
  * BadRequestError
15787
15046
  */
@@ -15832,23 +15091,15 @@ export type PromptsListPromptLabelEventsByLabelErrors = {
15832
15091
  503: ServiceUnavailableError;
15833
15092
  };
15834
15093
 
15835
- export type PromptsListPromptLabelEventsByLabelError = PromptsListPromptLabelEventsByLabelErrors[keyof PromptsListPromptLabelEventsByLabelErrors];
15094
+ export type PromptsGetPromptError = PromptsGetPromptErrors[keyof PromptsGetPromptErrors];
15836
15095
 
15837
- export type PromptsListPromptLabelEventsByLabelResponses = {
15096
+ export type PromptsGetPromptResponses = {
15838
15097
  /**
15839
15098
  * Success
15840
15099
  */
15841
15100
  200: {
15842
15101
  code: number;
15843
- data: {
15844
- items: Array<PromptLabelEvent>;
15845
- pagination: {
15846
- limit: number;
15847
- page: number;
15848
- total: number;
15849
- totalPages: number;
15850
- };
15851
- } | null;
15102
+ data: Prompt | null;
15852
15103
  error: {
15853
15104
  code: string;
15854
15105
  details?: unknown | null;
@@ -15875,27 +15126,25 @@ export type PromptsListPromptLabelEventsByLabelResponses = {
15875
15126
  };
15876
15127
  };
15877
15128
 
15878
- export type PromptsListPromptLabelEventsByLabelResponse = PromptsListPromptLabelEventsByLabelResponses[keyof PromptsListPromptLabelEventsByLabelResponses];
15129
+ export type PromptsGetPromptResponse = PromptsGetPromptResponses[keyof PromptsGetPromptResponses];
15879
15130
 
15880
- export type PromptsSetWeightedReleaseData = {
15131
+ export type PromptsUpdatePromptData = {
15881
15132
  body: {
15882
- reason: string;
15883
- variants: Array<{
15884
- name: string;
15885
- versionId: string;
15886
- weight: number;
15887
- }>;
15133
+ description?: string | null | null;
15134
+ name?: string | null;
15135
+ slug?: string | null;
15136
+ status?: 'active' | 'archived' | null;
15137
+ tags?: Array<string> | null;
15888
15138
  };
15889
15139
  path: {
15890
15140
  projectId: string;
15891
15141
  promptId: string;
15892
- label: string;
15893
15142
  };
15894
15143
  query?: never;
15895
- url: '/v1/projects/{projectId}/prompts/{promptId}/labels/{label}/weighted';
15144
+ url: '/v1/projects/{projectId}/prompts/{promptId}';
15896
15145
  };
15897
15146
 
15898
- export type PromptsSetWeightedReleaseErrors = {
15147
+ export type PromptsUpdatePromptErrors = {
15899
15148
  /**
15900
15149
  * BadRequestError
15901
15150
  */
@@ -15946,15 +15195,15 @@ export type PromptsSetWeightedReleaseErrors = {
15946
15195
  503: ServiceUnavailableError;
15947
15196
  };
15948
15197
 
15949
- export type PromptsSetWeightedReleaseError = PromptsSetWeightedReleaseErrors[keyof PromptsSetWeightedReleaseErrors];
15198
+ export type PromptsUpdatePromptError = PromptsUpdatePromptErrors[keyof PromptsUpdatePromptErrors];
15950
15199
 
15951
- export type PromptsSetWeightedReleaseResponses = {
15200
+ export type PromptsUpdatePromptResponses = {
15952
15201
  /**
15953
15202
  * Success
15954
15203
  */
15955
15204
  200: {
15956
15205
  code: number;
15957
- data: PromptRelease | null;
15206
+ data: Prompt | null;
15958
15207
  error: {
15959
15208
  code: string;
15960
15209
  details?: unknown | null;
@@ -15981,21 +15230,19 @@ export type PromptsSetWeightedReleaseResponses = {
15981
15230
  };
15982
15231
  };
15983
15232
 
15984
- export type PromptsSetWeightedReleaseResponse = PromptsSetWeightedReleaseResponses[keyof PromptsSetWeightedReleaseResponses];
15233
+ export type PromptsUpdatePromptResponse = PromptsUpdatePromptResponses[keyof PromptsUpdatePromptResponses];
15985
15234
 
15986
- export type PromptMetricsGetPromptRequestMetricsData = {
15987
- body?: never;
15235
+ export type PromptsImportPromptVersionData = {
15236
+ body: ImportPromptVersionInput;
15988
15237
  path: {
15989
15238
  projectId: string;
15990
15239
  promptId: string;
15991
15240
  };
15992
- query?: {
15993
- window?: string | null;
15994
- };
15995
- url: '/v1/projects/{projectId}/prompts/{promptId}/request-metrics';
15241
+ query?: never;
15242
+ url: '/v1/projects/{projectId}/prompts/{promptId}/imports';
15996
15243
  };
15997
15244
 
15998
- export type PromptMetricsGetPromptRequestMetricsErrors = {
15245
+ export type PromptsImportPromptVersionErrors = {
15999
15246
  /**
16000
15247
  * BadRequestError
16001
15248
  */
@@ -16045,27 +15292,16 @@ export type PromptMetricsGetPromptRequestMetricsErrors = {
16045
15292
  */
16046
15293
  503: ServiceUnavailableError;
16047
15294
  };
16048
-
16049
- export type PromptMetricsGetPromptRequestMetricsError = PromptMetricsGetPromptRequestMetricsErrors[keyof PromptMetricsGetPromptRequestMetricsErrors];
16050
-
16051
- export type PromptMetricsGetPromptRequestMetricsResponses = {
16052
- /**
16053
- * Success
16054
- */
16055
- 200: {
16056
- code: number;
16057
- data: {
16058
- bucketMinutes: number;
16059
- series: Array<{
16060
- points: Array<{
16061
- bucketStart: string;
16062
- requests: number;
16063
- }>;
16064
- totalRequests: number;
16065
- version: string;
16066
- }>;
16067
- windowHours: number;
16068
- } | null;
15295
+
15296
+ export type PromptsImportPromptVersionError = PromptsImportPromptVersionErrors[keyof PromptsImportPromptVersionErrors];
15297
+
15298
+ export type PromptsImportPromptVersionResponses = {
15299
+ /**
15300
+ * Success
15301
+ */
15302
+ 201: {
15303
+ code: number;
15304
+ data: PromptVersion | null;
16069
15305
  error: {
16070
15306
  code: string;
16071
15307
  details?: unknown | null;
@@ -16092,22 +15328,26 @@ export type PromptMetricsGetPromptRequestMetricsResponses = {
16092
15328
  };
16093
15329
  };
16094
15330
 
16095
- export type PromptMetricsGetPromptRequestMetricsResponse = PromptMetricsGetPromptRequestMetricsResponses[keyof PromptMetricsGetPromptRequestMetricsResponses];
15331
+ export type PromptsImportPromptVersionResponse = PromptsImportPromptVersionResponses[keyof PromptsImportPromptVersionResponses];
16096
15332
 
16097
- export type PromptsListPromptVersionsData = {
15333
+ export type PromptsListPromptLabelEventsByPromptData = {
16098
15334
  body?: never;
16099
15335
  path: {
16100
15336
  projectId: string;
16101
15337
  promptId: string;
16102
15338
  };
16103
15339
  query?: {
16104
- page?: number | null;
16105
- limit?: number | null;
15340
+ page?: string | null;
15341
+ limit?: string | null;
15342
+ label?: string | null;
15343
+ promptId?: string | null;
15344
+ since?: string | null;
15345
+ until?: string | null;
16106
15346
  };
16107
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions';
15347
+ url: '/v1/projects/{projectId}/prompts/{promptId}/label-events';
16108
15348
  };
16109
15349
 
16110
- export type PromptsListPromptVersionsErrors = {
15350
+ export type PromptsListPromptLabelEventsByPromptErrors = {
16111
15351
  /**
16112
15352
  * BadRequestError
16113
15353
  */
@@ -16158,15 +15398,23 @@ export type PromptsListPromptVersionsErrors = {
16158
15398
  503: ServiceUnavailableError;
16159
15399
  };
16160
15400
 
16161
- export type PromptsListPromptVersionsError = PromptsListPromptVersionsErrors[keyof PromptsListPromptVersionsErrors];
15401
+ export type PromptsListPromptLabelEventsByPromptError = PromptsListPromptLabelEventsByPromptErrors[keyof PromptsListPromptLabelEventsByPromptErrors];
16162
15402
 
16163
- export type PromptsListPromptVersionsResponses = {
15403
+ export type PromptsListPromptLabelEventsByPromptResponses = {
16164
15404
  /**
16165
15405
  * Success
16166
15406
  */
16167
15407
  200: {
16168
15408
  code: number;
16169
- data: Array<PromptVersion> | null;
15409
+ data: {
15410
+ items: Array<PromptLabelEvent>;
15411
+ pagination: {
15412
+ limit: number;
15413
+ page: number;
15414
+ total: number;
15415
+ totalPages: number;
15416
+ };
15417
+ } | null;
16170
15418
  error: {
16171
15419
  code: string;
16172
15420
  details?: unknown | null;
@@ -16193,27 +15441,23 @@ export type PromptsListPromptVersionsResponses = {
16193
15441
  };
16194
15442
  };
16195
15443
 
16196
- export type PromptsListPromptVersionsResponse = PromptsListPromptVersionsResponses[keyof PromptsListPromptVersionsResponses];
15444
+ export type PromptsListPromptLabelEventsByPromptResponse = PromptsListPromptLabelEventsByPromptResponses[keyof PromptsListPromptLabelEventsByPromptResponses];
16197
15445
 
16198
- export type PromptsCreatePromptVersionData = {
16199
- body: {
16200
- allowBlockRemovals?: Array<string> | null;
16201
- baseVersionId?: string | null;
16202
- changelog?: string | null;
16203
- format: 'text' | 'chat';
16204
- modelConfig?: unknown | null;
16205
- templateJson: unknown;
16206
- variablesSchema?: unknown | null;
16207
- };
15446
+ export type PromptsListPromptLabelsData = {
15447
+ body?: never;
16208
15448
  path: {
16209
15449
  projectId: string;
16210
15450
  promptId: string;
16211
15451
  };
16212
- query?: never;
16213
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions';
15452
+ query?: {
15453
+ asOf?: string | null;
15454
+ page?: number | null;
15455
+ limit?: number | null;
15456
+ };
15457
+ url: '/v1/projects/{projectId}/prompts/{promptId}/labels';
16214
15458
  };
16215
15459
 
16216
- export type PromptsCreatePromptVersionErrors = {
15460
+ export type PromptsListPromptLabelsErrors = {
16217
15461
  /**
16218
15462
  * BadRequestError
16219
15463
  */
@@ -16264,15 +15508,15 @@ export type PromptsCreatePromptVersionErrors = {
16264
15508
  503: ServiceUnavailableError;
16265
15509
  };
16266
15510
 
16267
- export type PromptsCreatePromptVersionError = PromptsCreatePromptVersionErrors[keyof PromptsCreatePromptVersionErrors];
15511
+ export type PromptsListPromptLabelsError = PromptsListPromptLabelsErrors[keyof PromptsListPromptLabelsErrors];
16268
15512
 
16269
- export type PromptsCreatePromptVersionResponses = {
15513
+ export type PromptsListPromptLabelsResponses = {
16270
15514
  /**
16271
15515
  * Success
16272
15516
  */
16273
- 201: {
15517
+ 200: {
16274
15518
  code: number;
16275
- data: PromptVersion | null;
15519
+ data: Array<PromptLabelPointer> | null;
16276
15520
  error: {
16277
15521
  code: string;
16278
15522
  details?: unknown | null;
@@ -16299,22 +15543,23 @@ export type PromptsCreatePromptVersionResponses = {
16299
15543
  };
16300
15544
  };
16301
15545
 
16302
- export type PromptsCreatePromptVersionResponse = PromptsCreatePromptVersionResponses[keyof PromptsCreatePromptVersionResponses];
15546
+ export type PromptsListPromptLabelsResponse = PromptsListPromptLabelsResponses[keyof PromptsListPromptLabelsResponses];
16303
15547
 
16304
- export type PromptsGetPromptVersionDiffData = {
16305
- body?: never;
15548
+ export type PromptsMovePromptLabelData = {
15549
+ body: {
15550
+ reason: string;
15551
+ versionId: string;
15552
+ };
16306
15553
  path: {
16307
15554
  projectId: string;
16308
15555
  promptId: string;
16309
- versionId: string;
16310
- };
16311
- query?: {
16312
- against?: string | null;
15556
+ label: string;
16313
15557
  };
16314
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionId}/diff';
15558
+ query?: never;
15559
+ url: '/v1/projects/{projectId}/prompts/{promptId}/labels/{label}';
16315
15560
  };
16316
15561
 
16317
- export type PromptsGetPromptVersionDiffErrors = {
15562
+ export type PromptsMovePromptLabelErrors = {
16318
15563
  /**
16319
15564
  * BadRequestError
16320
15565
  */
@@ -16365,100 +15610,15 @@ export type PromptsGetPromptVersionDiffErrors = {
16365
15610
  503: ServiceUnavailableError;
16366
15611
  };
16367
15612
 
16368
- export type PromptsGetPromptVersionDiffError = PromptsGetPromptVersionDiffErrors[keyof PromptsGetPromptVersionDiffErrors];
15613
+ export type PromptsMovePromptLabelError = PromptsMovePromptLabelErrors[keyof PromptsMovePromptLabelErrors];
16369
15614
 
16370
- export type PromptsGetPromptVersionDiffResponses = {
15615
+ export type PromptsMovePromptLabelResponses = {
16371
15616
  /**
16372
15617
  * Success
16373
15618
  */
16374
15619
  200: {
16375
15620
  code: number;
16376
- data: {
16377
- operations: Array<{
16378
- condition: {
16379
- kind: string;
16380
- };
16381
- content?: string | null;
16382
- name: string;
16383
- op: 'add';
16384
- role: 'system' | 'user' | 'assistant' | 'developer' | 'tool';
16385
- toolCallId?: string | null;
16386
- toolCalls?: Array<{
16387
- arguments: {
16388
- [key: string]: unknown;
16389
- };
16390
- id: string;
16391
- name: string;
16392
- }> | null;
16393
- } | {
16394
- condition: {
16395
- kind: string;
16396
- };
16397
- content?: string | null;
16398
- name: string;
16399
- op: 'remove';
16400
- role: 'system' | 'user' | 'assistant' | 'developer' | 'tool';
16401
- toolCallId?: string | null;
16402
- toolCalls?: Array<{
16403
- arguments: {
16404
- [key: string]: unknown;
16405
- };
16406
- id: string;
16407
- name: string;
16408
- }> | null;
16409
- } | {
16410
- after: string;
16411
- before: string;
16412
- name: string;
16413
- op: 'edit_content';
16414
- } | {
16415
- after: {
16416
- kind: string;
16417
- };
16418
- before: {
16419
- kind: string;
16420
- };
16421
- name: string;
16422
- op: 'edit_condition';
16423
- } | {
16424
- after: 'system' | 'user' | 'assistant' | 'developer' | 'tool';
16425
- before: 'system' | 'user' | 'assistant' | 'developer' | 'tool';
16426
- name: string;
16427
- op: 'edit_role';
16428
- } | {
16429
- after: boolean;
16430
- before: boolean;
16431
- name: string;
16432
- op: 'edit_required';
16433
- } | {
16434
- after: string;
16435
- before: string;
16436
- name: string;
16437
- op: 'edit_tool_call_id';
16438
- } | {
16439
- after: Array<{
16440
- arguments: {
16441
- [key: string]: unknown;
16442
- };
16443
- id: string;
16444
- name: string;
16445
- }>;
16446
- before: Array<{
16447
- arguments: {
16448
- [key: string]: unknown;
16449
- };
16450
- id: string;
16451
- name: string;
16452
- }>;
16453
- name: string;
16454
- op: 'edit_tool_calls';
16455
- } | {
16456
- fromIndex: number;
16457
- name: string;
16458
- op: 'reorder';
16459
- toIndex: number;
16460
- }>;
16461
- } | null;
15621
+ data: PromptLabelPointer | null;
16462
15622
  error: {
16463
15623
  code: string;
16464
15624
  details?: unknown | null;
@@ -16485,20 +15645,27 @@ export type PromptsGetPromptVersionDiffResponses = {
16485
15645
  };
16486
15646
  };
16487
15647
 
16488
- export type PromptsGetPromptVersionDiffResponse = PromptsGetPromptVersionDiffResponses[keyof PromptsGetPromptVersionDiffResponses];
15648
+ export type PromptsMovePromptLabelResponse = PromptsMovePromptLabelResponses[keyof PromptsMovePromptLabelResponses];
16489
15649
 
16490
- export type PromptsGetPromptVersionData = {
15650
+ export type PromptsListPromptLabelEventsByLabelData = {
16491
15651
  body?: never;
16492
15652
  path: {
16493
15653
  projectId: string;
16494
15654
  promptId: string;
16495
- versionNumber: string;
15655
+ label: string;
16496
15656
  };
16497
- query?: never;
16498
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionNumber}';
15657
+ query?: {
15658
+ page?: string | null;
15659
+ limit?: string | null;
15660
+ label?: string | null;
15661
+ promptId?: string | null;
15662
+ since?: string | null;
15663
+ until?: string | null;
15664
+ };
15665
+ url: '/v1/projects/{projectId}/prompts/{promptId}/labels/{label}/events';
16499
15666
  };
16500
15667
 
16501
- export type PromptsGetPromptVersionErrors = {
15668
+ export type PromptsListPromptLabelEventsByLabelErrors = {
16502
15669
  /**
16503
15670
  * BadRequestError
16504
15671
  */
@@ -16549,15 +15716,23 @@ export type PromptsGetPromptVersionErrors = {
16549
15716
  503: ServiceUnavailableError;
16550
15717
  };
16551
15718
 
16552
- export type PromptsGetPromptVersionError = PromptsGetPromptVersionErrors[keyof PromptsGetPromptVersionErrors];
15719
+ export type PromptsListPromptLabelEventsByLabelError = PromptsListPromptLabelEventsByLabelErrors[keyof PromptsListPromptLabelEventsByLabelErrors];
16553
15720
 
16554
- export type PromptsGetPromptVersionResponses = {
15721
+ export type PromptsListPromptLabelEventsByLabelResponses = {
16555
15722
  /**
16556
15723
  * Success
16557
15724
  */
16558
15725
  200: {
16559
15726
  code: number;
16560
- data: PromptVersion | null;
15727
+ data: {
15728
+ items: Array<PromptLabelEvent>;
15729
+ pagination: {
15730
+ limit: number;
15731
+ page: number;
15732
+ total: number;
15733
+ totalPages: number;
15734
+ };
15735
+ } | null;
16561
15736
  error: {
16562
15737
  code: string;
16563
15738
  details?: unknown | null;
@@ -16584,20 +15759,21 @@ export type PromptsGetPromptVersionResponses = {
16584
15759
  };
16585
15760
  };
16586
15761
 
16587
- export type PromptsGetPromptVersionResponse = PromptsGetPromptVersionResponses[keyof PromptsGetPromptVersionResponses];
15762
+ export type PromptsListPromptLabelEventsByLabelResponse = PromptsListPromptLabelEventsByLabelResponses[keyof PromptsListPromptLabelEventsByLabelResponses];
16588
15763
 
16589
- export type PromptsGetPromptReviewStateData = {
15764
+ export type PromptMetricsGetPromptRequestMetricsData = {
16590
15765
  body?: never;
16591
15766
  path: {
16592
15767
  projectId: string;
16593
15768
  promptId: string;
16594
- versionNumber: string;
16595
15769
  };
16596
- query?: never;
16597
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionNumber}/reviews';
15770
+ query?: {
15771
+ window?: string | null;
15772
+ };
15773
+ url: '/v1/projects/{projectId}/prompts/{promptId}/request-metrics';
16598
15774
  };
16599
15775
 
16600
- export type PromptsGetPromptReviewStateErrors = {
15776
+ export type PromptMetricsGetPromptRequestMetricsErrors = {
16601
15777
  /**
16602
15778
  * BadRequestError
16603
15779
  */
@@ -16648,33 +15824,25 @@ export type PromptsGetPromptReviewStateErrors = {
16648
15824
  503: ServiceUnavailableError;
16649
15825
  };
16650
15826
 
16651
- export type PromptsGetPromptReviewStateError = PromptsGetPromptReviewStateErrors[keyof PromptsGetPromptReviewStateErrors];
15827
+ export type PromptMetricsGetPromptRequestMetricsError = PromptMetricsGetPromptRequestMetricsErrors[keyof PromptMetricsGetPromptRequestMetricsErrors];
16652
15828
 
16653
- export type PromptsGetPromptReviewStateResponses = {
15829
+ export type PromptMetricsGetPromptRequestMetricsResponses = {
16654
15830
  /**
16655
15831
  * Success
16656
15832
  */
16657
15833
  200: {
16658
15834
  code: number;
16659
15835
  data: {
16660
- activeDecisions: Array<{
16661
- createdAt: string;
16662
- decision: 'approve' | 'reject' | 'request_changes' | 'withdraw';
16663
- hasActiveRejection: boolean;
16664
- reviewId: string;
16665
- reviewerPrincipalId: string;
16666
- }>;
16667
- approvalCount: number;
16668
- callerHasActiveRejection: boolean;
16669
- hasActiveRejection: boolean;
16670
- reviews: Array<{
16671
- createdAt: string;
16672
- decision: 'approve' | 'reject' | 'request_changes' | 'withdraw';
16673
- id: string;
16674
- note: string | null;
16675
- reviewerDisplayName: string | null;
16676
- reviewerPrincipalId: string;
15836
+ bucketMinutes: number;
15837
+ series: Array<{
15838
+ points: Array<{
15839
+ bucketStart: string;
15840
+ requests: number;
15841
+ }>;
15842
+ totalRequests: number;
15843
+ version: string;
16677
15844
  }>;
15845
+ windowHours: number;
16678
15846
  } | null;
16679
15847
  error: {
16680
15848
  code: string;
@@ -16702,23 +15870,22 @@ export type PromptsGetPromptReviewStateResponses = {
16702
15870
  };
16703
15871
  };
16704
15872
 
16705
- export type PromptsGetPromptReviewStateResponse = PromptsGetPromptReviewStateResponses[keyof PromptsGetPromptReviewStateResponses];
15873
+ export type PromptMetricsGetPromptRequestMetricsResponse = PromptMetricsGetPromptRequestMetricsResponses[keyof PromptMetricsGetPromptRequestMetricsResponses];
16706
15874
 
16707
- export type PromptsSubmitPromptReviewData = {
16708
- body: {
16709
- decision: 'approve' | 'reject' | 'request_changes';
16710
- note?: string | null;
16711
- };
15875
+ export type PromptsListPromptVersionsData = {
15876
+ body?: never;
16712
15877
  path: {
16713
15878
  projectId: string;
16714
15879
  promptId: string;
16715
- versionNumber: string;
16716
15880
  };
16717
- query?: never;
16718
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionNumber}/reviews';
15881
+ query?: {
15882
+ page?: number | null;
15883
+ limit?: number | null;
15884
+ };
15885
+ url: '/v1/projects/{projectId}/prompts/{promptId}/versions';
16719
15886
  };
16720
15887
 
16721
- export type PromptsSubmitPromptReviewErrors = {
15888
+ export type PromptsListPromptVersionsErrors = {
16722
15889
  /**
16723
15890
  * BadRequestError
16724
15891
  */
@@ -16769,27 +15936,15 @@ export type PromptsSubmitPromptReviewErrors = {
16769
15936
  503: ServiceUnavailableError;
16770
15937
  };
16771
15938
 
16772
- export type PromptsSubmitPromptReviewError = PromptsSubmitPromptReviewErrors[keyof PromptsSubmitPromptReviewErrors];
15939
+ export type PromptsListPromptVersionsError = PromptsListPromptVersionsErrors[keyof PromptsListPromptVersionsErrors];
16773
15940
 
16774
- export type PromptsSubmitPromptReviewResponses = {
15941
+ export type PromptsListPromptVersionsResponses = {
16775
15942
  /**
16776
15943
  * Success
16777
15944
  */
16778
- 201: {
15945
+ 200: {
16779
15946
  code: number;
16780
- data: {
16781
- approvalState: {
16782
- approvalCount: number;
16783
- hasActiveRejection: boolean;
16784
- };
16785
- review: {
16786
- createdAt: string;
16787
- decision: 'approve' | 'reject' | 'request_changes' | 'withdraw';
16788
- id: string;
16789
- note: string | null;
16790
- reviewerPrincipalId: string;
16791
- };
16792
- } | null;
15947
+ data: Array<PromptVersion> | null;
16793
15948
  error: {
16794
15949
  code: string;
16795
15950
  details?: unknown | null;
@@ -16816,22 +15971,27 @@ export type PromptsSubmitPromptReviewResponses = {
16816
15971
  };
16817
15972
  };
16818
15973
 
16819
- export type PromptsSubmitPromptReviewResponse = PromptsSubmitPromptReviewResponses[keyof PromptsSubmitPromptReviewResponses];
15974
+ export type PromptsListPromptVersionsResponse = PromptsListPromptVersionsResponses[keyof PromptsListPromptVersionsResponses];
16820
15975
 
16821
- export type PromptsWithdrawPromptReviewData = {
15976
+ export type PromptsCreatePromptVersionData = {
16822
15977
  body: {
16823
- note?: string | null;
15978
+ allowBlockRemovals?: Array<string> | null;
15979
+ baseVersionId?: string | null;
15980
+ changelog?: string | null;
15981
+ format: 'text' | 'chat' | 'skill';
15982
+ modelConfig?: unknown | null;
15983
+ templateJson: unknown;
15984
+ variablesSchema?: unknown | null;
16824
15985
  };
16825
15986
  path: {
16826
15987
  projectId: string;
16827
15988
  promptId: string;
16828
- versionNumber: string;
16829
15989
  };
16830
15990
  query?: never;
16831
- url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionNumber}/reviews:withdraw';
15991
+ url: '/v1/projects/{projectId}/prompts/{promptId}/versions';
16832
15992
  };
16833
15993
 
16834
- export type PromptsWithdrawPromptReviewErrors = {
15994
+ export type PromptsCreatePromptVersionErrors = {
16835
15995
  /**
16836
15996
  * BadRequestError
16837
15997
  */
@@ -16882,27 +16042,15 @@ export type PromptsWithdrawPromptReviewErrors = {
16882
16042
  503: ServiceUnavailableError;
16883
16043
  };
16884
16044
 
16885
- export type PromptsWithdrawPromptReviewError = PromptsWithdrawPromptReviewErrors[keyof PromptsWithdrawPromptReviewErrors];
16045
+ export type PromptsCreatePromptVersionError = PromptsCreatePromptVersionErrors[keyof PromptsCreatePromptVersionErrors];
16886
16046
 
16887
- export type PromptsWithdrawPromptReviewResponses = {
16047
+ export type PromptsCreatePromptVersionResponses = {
16888
16048
  /**
16889
16049
  * Success
16890
16050
  */
16891
16051
  201: {
16892
16052
  code: number;
16893
- data: {
16894
- approvalState: {
16895
- approvalCount: number;
16896
- hasActiveRejection: boolean;
16897
- };
16898
- review: {
16899
- createdAt: string;
16900
- decision: 'approve' | 'reject' | 'request_changes' | 'withdraw';
16901
- id: string;
16902
- note: string | null;
16903
- reviewerPrincipalId: string;
16904
- };
16905
- } | null;
16053
+ data: PromptVersion | null;
16906
16054
  error: {
16907
16055
  code: string;
16908
16056
  details?: unknown | null;
@@ -16929,25 +16077,20 @@ export type PromptsWithdrawPromptReviewResponses = {
16929
16077
  };
16930
16078
  };
16931
16079
 
16932
- export type PromptsWithdrawPromptReviewResponse = PromptsWithdrawPromptReviewResponses[keyof PromptsWithdrawPromptReviewResponses];
16080
+ export type PromptsCreatePromptVersionResponse = PromptsCreatePromptVersionResponses[keyof PromptsCreatePromptVersionResponses];
16933
16081
 
16934
- export type PromptsResolvePromptData = {
16935
- body: {
16936
- labels: Array<string>;
16937
- slug: string;
16938
- subject?: string | null;
16939
- variables?: {
16940
- [key: string]: unknown;
16941
- } | null;
16942
- };
16082
+ export type PromptsGetPromptVersionData = {
16083
+ body?: never;
16943
16084
  path: {
16944
16085
  projectId: string;
16086
+ promptId: string;
16087
+ versionNumber: string;
16945
16088
  };
16946
16089
  query?: never;
16947
- url: '/v1/projects/{projectId}/prompts:resolve';
16090
+ url: '/v1/projects/{projectId}/prompts/{promptId}/versions/{versionNumber}';
16948
16091
  };
16949
16092
 
16950
- export type PromptsResolvePromptErrors = {
16093
+ export type PromptsGetPromptVersionErrors = {
16951
16094
  /**
16952
16095
  * BadRequestError
16953
16096
  */
@@ -16998,15 +16141,15 @@ export type PromptsResolvePromptErrors = {
16998
16141
  503: ServiceUnavailableError;
16999
16142
  };
17000
16143
 
17001
- export type PromptsResolvePromptError = PromptsResolvePromptErrors[keyof PromptsResolvePromptErrors];
16144
+ export type PromptsGetPromptVersionError = PromptsGetPromptVersionErrors[keyof PromptsGetPromptVersionErrors];
17002
16145
 
17003
- export type PromptsResolvePromptResponses = {
16146
+ export type PromptsGetPromptVersionResponses = {
17004
16147
  /**
17005
16148
  * Success
17006
16149
  */
17007
16150
  200: {
17008
16151
  code: number;
17009
- data: ResolvedPrompt | null;
16152
+ data: PromptVersion | null;
17010
16153
  error: {
17011
16154
  code: string;
17012
16155
  details?: unknown | null;
@@ -17033,7 +16176,7 @@ export type PromptsResolvePromptResponses = {
17033
16176
  };
17034
16177
  };
17035
16178
 
17036
- export type PromptsResolvePromptResponse = PromptsResolvePromptResponses[keyof PromptsResolvePromptResponses];
16179
+ export type PromptsGetPromptVersionResponse = PromptsGetPromptVersionResponses[keyof PromptsGetPromptVersionResponses];
17037
16180
 
17038
16181
  export type CredentialLifecycleRenameCredentialData = {
17039
16182
  body: {
@@ -19452,6 +18595,7 @@ export type RoutingProvidersCreateRoutingProviderResponse = RoutingProvidersCrea
19452
18595
 
19453
18596
  export type RoutingProvidersConnectRoutingProviderData = {
19454
18597
  body: {
18598
+ blockedModels?: Array<string> | null;
19455
18599
  credential: {
19456
18600
  apiKey: string;
19457
18601
  label?: string | null;
@@ -19481,6 +18625,7 @@ export type RoutingProvidersConnectRoutingProviderData = {
19481
18625
  credentialId: string;
19482
18626
  type: 'existing';
19483
18627
  };
18628
+ modelPolicy?: 'allowlist' | 'denylist' | null;
19484
18629
  models: Array<string>;
19485
18630
  provider: {
19486
18631
  apiVersion?: string | null;
@@ -21456,7 +20601,9 @@ export type ProviderConfigDraftsUpdateProviderDraftData = {
21456
20601
  body: {
21457
20602
  configSnapshotPatch: {
21458
20603
  baseUrl?: string | null | null;
20604
+ blockedModels?: Array<string> | null | null;
21459
20605
  customModelIds?: Array<string> | null | null;
20606
+ modelPolicy?: 'allowlist' | 'denylist' | null | null;
21460
20607
  models?: Array<string> | null | null;
21461
20608
  passthroughMode?: 'managed_precedence' | 'caller_precedence' | 'disabled' | null | null;
21462
20609
  providerRegion?: string | null | null;
@@ -26831,6 +25978,7 @@ export type ProjectsListProjectsResponses = {
26831
25978
  status: 'active' | 'archived' | 'deleted';
26832
25979
  updatedAt: string;
26833
25980
  workspaceId: string;
25981
+ workspaceSlug: string;
26834
25982
  }> | null;
26835
25983
  error: {
26836
25984
  code: string;
@@ -26942,6 +26090,7 @@ export type ProjectsCreateProjectResponses = {
26942
26090
  status: 'active' | 'archived' | 'deleted';
26943
26091
  updatedAt: string;
26944
26092
  workspaceId: string;
26093
+ workspaceSlug: string;
26945
26094
  } | null;
26946
26095
  error: {
26947
26096
  code: string;