@robosystems/client 0.2.2 → 0.2.3

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.
package/types.gen.ts CHANGED
@@ -1231,12 +1231,12 @@ export type CustomSchemaDefinition = {
1231
1231
  export type CypherQueryRequest = {
1232
1232
  /**
1233
1233
  * Query
1234
- * The Cypher query to execute
1234
+ * The Cypher query to execute. Use parameters ($param_name) for all dynamic values to prevent injection attacks.
1235
1235
  */
1236
1236
  query: string;
1237
1237
  /**
1238
1238
  * Parameters
1239
- * Optional parameters for the Cypher query
1239
+ * Query parameters for safe value substitution. ALWAYS use parameters instead of string interpolation.
1240
1240
  */
1241
1241
  parameters?: {
1242
1242
  [key: string]: unknown;
@@ -2623,7 +2623,7 @@ export type SchemaExportResponse = {
2623
2623
  graph_id: string;
2624
2624
  /**
2625
2625
  * Schema Definition
2626
- * Exported schema definition
2626
+ * Exported schema definition (format depends on 'format' parameter)
2627
2627
  */
2628
2628
  schema_definition: {
2629
2629
  [key: string]: unknown;
@@ -2640,13 +2640,35 @@ export type SchemaExportResponse = {
2640
2640
  exported_at: string;
2641
2641
  /**
2642
2642
  * Data Stats
2643
- * Data statistics if requested
2643
+ * Data statistics if requested (only when include_data_stats=true)
2644
2644
  */
2645
2645
  data_stats?: {
2646
2646
  [key: string]: unknown;
2647
2647
  } | null;
2648
2648
  };
2649
2649
 
2650
+ /**
2651
+ * SchemaInfoResponse
2652
+ * Response model for runtime schema introspection.
2653
+ *
2654
+ * This model represents the actual current state of the graph database,
2655
+ * showing what node labels, relationship types, and properties exist right now.
2656
+ */
2657
+ export type SchemaInfoResponse = {
2658
+ /**
2659
+ * Graph Id
2660
+ * Graph database identifier
2661
+ */
2662
+ graph_id: string;
2663
+ /**
2664
+ * Schema
2665
+ * Runtime schema information showing actual database structure
2666
+ */
2667
+ schema: {
2668
+ [key: string]: unknown;
2669
+ };
2670
+ };
2671
+
2650
2672
  /**
2651
2673
  * SchemaValidationRequest
2652
2674
  * Request model for schema validation.
@@ -2688,24 +2710,24 @@ export type SchemaValidationResponse = {
2688
2710
  message: string;
2689
2711
  /**
2690
2712
  * Errors
2691
- * List of validation errors
2713
+ * List of validation errors (only present when valid=false)
2692
2714
  */
2693
2715
  errors?: Array<string> | null;
2694
2716
  /**
2695
2717
  * Warnings
2696
- * List of warnings
2718
+ * List of validation warnings (schema is still valid but has potential issues)
2697
2719
  */
2698
2720
  warnings?: Array<string> | null;
2699
2721
  /**
2700
2722
  * Stats
2701
- * Schema statistics (nodes, relationships, properties)
2723
+ * Schema statistics (only present when valid=true)
2702
2724
  */
2703
2725
  stats?: {
2704
2726
  [key: string]: number;
2705
2727
  } | null;
2706
2728
  /**
2707
2729
  * Compatibility
2708
- * Compatibility check results if requested
2730
+ * Compatibility check results (only when check_compatibility specified)
2709
2731
  */
2710
2732
  compatibility?: {
2711
2733
  [key: string]: unknown;
@@ -3180,9 +3202,14 @@ export type TableListResponse = {
3180
3202
  export type TableQueryRequest = {
3181
3203
  /**
3182
3204
  * Sql
3183
- * SQL query to execute on staging tables
3205
+ * SQL query to execute on staging tables. Use ? placeholders or $param_name for dynamic values to prevent SQL injection.
3184
3206
  */
3185
3207
  sql: string;
3208
+ /**
3209
+ * Parameters
3210
+ * Query parameters for safe value substitution. ALWAYS use parameters instead of string concatenation.
3211
+ */
3212
+ parameters?: Array<unknown> | null;
3186
3213
  };
3187
3214
 
3188
3215
  /**
@@ -3659,26 +3686,11 @@ export type LoginUserResponse = LoginUserResponses[keyof LoginUserResponses];
3659
3686
 
3660
3687
  export type LogoutUserData = {
3661
3688
  body?: never;
3662
- headers?: {
3663
- /**
3664
- * Authorization
3665
- */
3666
- authorization?: string | null;
3667
- };
3668
3689
  path?: never;
3669
3690
  query?: never;
3670
3691
  url: '/v1/auth/logout';
3671
3692
  };
3672
3693
 
3673
- export type LogoutUserErrors = {
3674
- /**
3675
- * Validation Error
3676
- */
3677
- 422: HttpValidationError;
3678
- };
3679
-
3680
- export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
3681
-
3682
3694
  export type LogoutUserResponses = {
3683
3695
  /**
3684
3696
  * Response Logoutuser
@@ -3693,12 +3705,6 @@ export type LogoutUserResponse = LogoutUserResponses[keyof LogoutUserResponses];
3693
3705
 
3694
3706
  export type GetCurrentAuthUserData = {
3695
3707
  body?: never;
3696
- headers?: {
3697
- /**
3698
- * Authorization
3699
- */
3700
- authorization?: string | null;
3701
- };
3702
3708
  path?: never;
3703
3709
  query?: never;
3704
3710
  url: '/v1/auth/me';
@@ -3709,10 +3715,6 @@ export type GetCurrentAuthUserErrors = {
3709
3715
  * Not authenticated
3710
3716
  */
3711
3717
  401: ErrorResponse;
3712
- /**
3713
- * Validation Error
3714
- */
3715
- 422: HttpValidationError;
3716
3718
  };
3717
3719
 
3718
3720
  export type GetCurrentAuthUserError = GetCurrentAuthUserErrors[keyof GetCurrentAuthUserErrors];
@@ -3731,12 +3733,6 @@ export type GetCurrentAuthUserResponse = GetCurrentAuthUserResponses[keyof GetCu
3731
3733
 
3732
3734
  export type RefreshAuthSessionData = {
3733
3735
  body?: never;
3734
- headers?: {
3735
- /**
3736
- * Authorization
3737
- */
3738
- authorization?: string | null;
3739
- };
3740
3736
  path?: never;
3741
3737
  query?: never;
3742
3738
  url: '/v1/auth/refresh';
@@ -3747,10 +3743,6 @@ export type RefreshAuthSessionErrors = {
3747
3743
  * Not authenticated
3748
3744
  */
3749
3745
  401: ErrorResponse;
3750
- /**
3751
- * Validation Error
3752
- */
3753
- 422: HttpValidationError;
3754
3746
  };
3755
3747
 
3756
3748
  export type RefreshAuthSessionError = RefreshAuthSessionErrors[keyof RefreshAuthSessionErrors];
@@ -3766,12 +3758,6 @@ export type RefreshAuthSessionResponse = RefreshAuthSessionResponses[keyof Refre
3766
3758
 
3767
3759
  export type ResendVerificationEmailData = {
3768
3760
  body?: never;
3769
- headers?: {
3770
- /**
3771
- * Authorization
3772
- */
3773
- authorization?: string | null;
3774
- };
3775
3761
  path?: never;
3776
3762
  query?: never;
3777
3763
  url: '/v1/auth/email/resend';
@@ -3782,10 +3768,6 @@ export type ResendVerificationEmailErrors = {
3782
3768
  * Email already verified
3783
3769
  */
3784
3770
  400: ErrorResponse;
3785
- /**
3786
- * Validation Error
3787
- */
3788
- 422: HttpValidationError;
3789
3771
  /**
3790
3772
  * Rate limit exceeded
3791
3773
  */
@@ -3974,12 +3956,6 @@ export type ResetPasswordResponse = ResetPasswordResponses[keyof ResetPasswordRe
3974
3956
 
3975
3957
  export type GenerateSsoTokenData = {
3976
3958
  body?: never;
3977
- headers?: {
3978
- /**
3979
- * Authorization
3980
- */
3981
- authorization?: string | null;
3982
- };
3983
3959
  path?: never;
3984
3960
  query?: never;
3985
3961
  url: '/v1/auth/sso-token';
@@ -4101,32 +4077,11 @@ export type GetServiceStatusResponse = GetServiceStatusResponses[keyof GetServic
4101
4077
 
4102
4078
  export type GetCurrentUserData = {
4103
4079
  body?: never;
4104
- headers?: {
4105
- /**
4106
- * Authorization
4107
- */
4108
- authorization?: string | null;
4109
- };
4110
4080
  path?: never;
4111
- query?: {
4112
- /**
4113
- * Token
4114
- * JWT token for SSE authentication
4115
- */
4116
- token?: string | null;
4117
- };
4081
+ query?: never;
4118
4082
  url: '/v1/user';
4119
4083
  };
4120
4084
 
4121
- export type GetCurrentUserErrors = {
4122
- /**
4123
- * Validation Error
4124
- */
4125
- 422: HttpValidationError;
4126
- };
4127
-
4128
- export type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
4129
-
4130
4085
  export type GetCurrentUserResponses = {
4131
4086
  /**
4132
4087
  * Successful Response
@@ -4138,20 +4093,8 @@ export type GetCurrentUserResponse = GetCurrentUserResponses[keyof GetCurrentUse
4138
4093
 
4139
4094
  export type UpdateUserData = {
4140
4095
  body: UpdateUserRequest;
4141
- headers?: {
4142
- /**
4143
- * Authorization
4144
- */
4145
- authorization?: string | null;
4146
- };
4147
4096
  path?: never;
4148
- query?: {
4149
- /**
4150
- * Token
4151
- * JWT token for SSE authentication
4152
- */
4153
- token?: string | null;
4154
- };
4097
+ query?: never;
4155
4098
  url: '/v1/user';
4156
4099
  };
4157
4100
 
@@ -4175,28 +4118,12 @@ export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
4175
4118
 
4176
4119
  export type GetAllCreditSummariesData = {
4177
4120
  body?: never;
4178
- headers?: {
4179
- /**
4180
- * Authorization
4181
- */
4182
- authorization?: string | null;
4183
- };
4184
4121
  path?: never;
4185
- query?: {
4186
- /**
4187
- * Token
4188
- * JWT token for SSE authentication
4189
- */
4190
- token?: string | null;
4191
- };
4122
+ query?: never;
4192
4123
  url: '/v1/user/credits';
4193
4124
  };
4194
4125
 
4195
4126
  export type GetAllCreditSummariesErrors = {
4196
- /**
4197
- * Validation Error
4198
- */
4199
- 422: HttpValidationError;
4200
4127
  /**
4201
4128
  * Failed to retrieve credit summaries
4202
4129
  */
@@ -4219,20 +4146,8 @@ export type GetAllCreditSummariesResponse = GetAllCreditSummariesResponses[keyof
4219
4146
 
4220
4147
  export type UpdateUserPasswordData = {
4221
4148
  body: UpdatePasswordRequest;
4222
- headers?: {
4223
- /**
4224
- * Authorization
4225
- */
4226
- authorization?: string | null;
4227
- };
4228
4149
  path?: never;
4229
- query?: {
4230
- /**
4231
- * Token
4232
- * JWT token for SSE authentication
4233
- */
4234
- token?: string | null;
4235
- };
4150
+ query?: never;
4236
4151
  url: '/v1/user/password';
4237
4152
  };
4238
4153
 
@@ -4268,32 +4183,11 @@ export type UpdateUserPasswordResponse = UpdateUserPasswordResponses[keyof Updat
4268
4183
 
4269
4184
  export type ListUserApiKeysData = {
4270
4185
  body?: never;
4271
- headers?: {
4272
- /**
4273
- * Authorization
4274
- */
4275
- authorization?: string | null;
4276
- };
4277
4186
  path?: never;
4278
- query?: {
4279
- /**
4280
- * Token
4281
- * JWT token for SSE authentication
4282
- */
4283
- token?: string | null;
4284
- };
4187
+ query?: never;
4285
4188
  url: '/v1/user/api-keys';
4286
4189
  };
4287
4190
 
4288
- export type ListUserApiKeysErrors = {
4289
- /**
4290
- * Validation Error
4291
- */
4292
- 422: HttpValidationError;
4293
- };
4294
-
4295
- export type ListUserApiKeysError = ListUserApiKeysErrors[keyof ListUserApiKeysErrors];
4296
-
4297
4191
  export type ListUserApiKeysResponses = {
4298
4192
  /**
4299
4193
  * Successful Response
@@ -4305,20 +4199,8 @@ export type ListUserApiKeysResponse = ListUserApiKeysResponses[keyof ListUserApi
4305
4199
 
4306
4200
  export type CreateUserApiKeyData = {
4307
4201
  body: CreateApiKeyRequest;
4308
- headers?: {
4309
- /**
4310
- * Authorization
4311
- */
4312
- authorization?: string | null;
4313
- };
4314
4202
  path?: never;
4315
- query?: {
4316
- /**
4317
- * Token
4318
- * JWT token for SSE authentication
4319
- */
4320
- token?: string | null;
4321
- };
4203
+ query?: never;
4322
4204
  url: '/v1/user/api-keys';
4323
4205
  };
4324
4206
 
@@ -4342,25 +4224,13 @@ export type CreateUserApiKeyResponse = CreateUserApiKeyResponses[keyof CreateUse
4342
4224
 
4343
4225
  export type RevokeUserApiKeyData = {
4344
4226
  body?: never;
4345
- headers?: {
4346
- /**
4347
- * Authorization
4348
- */
4349
- authorization?: string | null;
4350
- };
4351
4227
  path: {
4352
4228
  /**
4353
4229
  * Api Key Id
4354
4230
  */
4355
4231
  api_key_id: string;
4356
4232
  };
4357
- query?: {
4358
- /**
4359
- * Token
4360
- * JWT token for SSE authentication
4361
- */
4362
- token?: string | null;
4363
- };
4233
+ query?: never;
4364
4234
  url: '/v1/user/api-keys/{api_key_id}';
4365
4235
  };
4366
4236
 
@@ -4392,25 +4262,13 @@ export type RevokeUserApiKeyResponse = RevokeUserApiKeyResponses[keyof RevokeUse
4392
4262
 
4393
4263
  export type UpdateUserApiKeyData = {
4394
4264
  body: UpdateApiKeyRequest;
4395
- headers?: {
4396
- /**
4397
- * Authorization
4398
- */
4399
- authorization?: string | null;
4400
- };
4401
4265
  path: {
4402
4266
  /**
4403
4267
  * Api Key Id
4404
4268
  */
4405
4269
  api_key_id: string;
4406
4270
  };
4407
- query?: {
4408
- /**
4409
- * Token
4410
- * JWT token for SSE authentication
4411
- */
4412
- token?: string | null;
4413
- };
4271
+ query?: never;
4414
4272
  url: '/v1/user/api-keys/{api_key_id}';
4415
4273
  };
4416
4274
 
@@ -4434,20 +4292,8 @@ export type UpdateUserApiKeyResponse = UpdateUserApiKeyResponses[keyof UpdateUse
4434
4292
 
4435
4293
  export type GetUserLimitsData = {
4436
4294
  body?: never;
4437
- headers?: {
4438
- /**
4439
- * Authorization
4440
- */
4441
- authorization?: string | null;
4442
- };
4443
4295
  path?: never;
4444
- query?: {
4445
- /**
4446
- * Token
4447
- * JWT token for SSE authentication
4448
- */
4449
- token?: string | null;
4450
- };
4296
+ query?: never;
4451
4297
  url: '/v1/user/limits';
4452
4298
  };
4453
4299
 
@@ -4456,14 +4302,8 @@ export type GetUserLimitsErrors = {
4456
4302
  * User limits not found
4457
4303
  */
4458
4304
  404: unknown;
4459
- /**
4460
- * Validation Error
4461
- */
4462
- 422: HttpValidationError;
4463
4305
  };
4464
4306
 
4465
- export type GetUserLimitsError = GetUserLimitsErrors[keyof GetUserLimitsErrors];
4466
-
4467
4307
  export type GetUserLimitsResponses = {
4468
4308
  /**
4469
4309
  * User limits retrieved successfully
@@ -4475,32 +4315,11 @@ export type GetUserLimitsResponse = GetUserLimitsResponses[keyof GetUserLimitsRe
4475
4315
 
4476
4316
  export type GetUserUsageData = {
4477
4317
  body?: never;
4478
- headers?: {
4479
- /**
4480
- * Authorization
4481
- */
4482
- authorization?: string | null;
4483
- };
4484
4318
  path?: never;
4485
- query?: {
4486
- /**
4487
- * Token
4488
- * JWT token for SSE authentication
4489
- */
4490
- token?: string | null;
4491
- };
4319
+ query?: never;
4492
4320
  url: '/v1/user/limits/usage';
4493
4321
  };
4494
4322
 
4495
- export type GetUserUsageErrors = {
4496
- /**
4497
- * Validation Error
4498
- */
4499
- 422: HttpValidationError;
4500
- };
4501
-
4502
- export type GetUserUsageError = GetUserUsageErrors[keyof GetUserUsageErrors];
4503
-
4504
4323
  export type GetUserUsageResponses = {
4505
4324
  /**
4506
4325
  * User usage statistics retrieved successfully
@@ -4512,36 +4331,15 @@ export type GetUserUsageResponse = GetUserUsageResponses[keyof GetUserUsageRespo
4512
4331
 
4513
4332
  export type GetAllSharedRepositoryLimitsData = {
4514
4333
  body?: never;
4515
- headers?: {
4516
- /**
4517
- * Authorization
4518
- */
4519
- authorization?: string | null;
4520
- };
4521
4334
  path?: never;
4522
- query?: {
4523
- /**
4524
- * Token
4525
- * JWT token for SSE authentication
4526
- */
4527
- token?: string | null;
4528
- };
4335
+ query?: never;
4529
4336
  url: '/v1/user/limits/shared-repositories/summary';
4530
4337
  };
4531
4338
 
4532
- export type GetAllSharedRepositoryLimitsErrors = {
4339
+ export type GetAllSharedRepositoryLimitsResponses = {
4533
4340
  /**
4534
- * Validation Error
4535
- */
4536
- 422: HttpValidationError;
4537
- };
4538
-
4539
- export type GetAllSharedRepositoryLimitsError = GetAllSharedRepositoryLimitsErrors[keyof GetAllSharedRepositoryLimitsErrors];
4540
-
4541
- export type GetAllSharedRepositoryLimitsResponses = {
4542
- /**
4543
- * Response Getallsharedrepositorylimits
4544
- * Successful Response
4341
+ * Response Getallsharedrepositorylimits
4342
+ * Successful Response
4545
4343
  */
4546
4344
  200: {
4547
4345
  [key: string]: unknown;
@@ -4552,12 +4350,6 @@ export type GetAllSharedRepositoryLimitsResponse = GetAllSharedRepositoryLimitsR
4552
4350
 
4553
4351
  export type GetSharedRepositoryLimitsData = {
4554
4352
  body?: never;
4555
- headers?: {
4556
- /**
4557
- * Authorization
4558
- */
4559
- authorization?: string | null;
4560
- };
4561
4353
  path: {
4562
4354
  /**
4563
4355
  * Repository
@@ -4565,13 +4357,7 @@ export type GetSharedRepositoryLimitsData = {
4565
4357
  */
4566
4358
  repository: string;
4567
4359
  };
4568
- query?: {
4569
- /**
4570
- * Token
4571
- * JWT token for SSE authentication
4572
- */
4573
- token?: string | null;
4574
- };
4360
+ query?: never;
4575
4361
  url: '/v1/user/limits/shared-repositories/{repository}';
4576
4362
  };
4577
4363
 
@@ -4598,32 +4384,11 @@ export type GetSharedRepositoryLimitsResponse = GetSharedRepositoryLimitsRespons
4598
4384
 
4599
4385
  export type GetUserUsageOverviewData = {
4600
4386
  body?: never;
4601
- headers?: {
4602
- /**
4603
- * Authorization
4604
- */
4605
- authorization?: string | null;
4606
- };
4607
4387
  path?: never;
4608
- query?: {
4609
- /**
4610
- * Token
4611
- * JWT token for SSE authentication
4612
- */
4613
- token?: string | null;
4614
- };
4388
+ query?: never;
4615
4389
  url: '/v1/user/analytics/overview';
4616
4390
  };
4617
4391
 
4618
- export type GetUserUsageOverviewErrors = {
4619
- /**
4620
- * Validation Error
4621
- */
4622
- 422: HttpValidationError;
4623
- };
4624
-
4625
- export type GetUserUsageOverviewError = GetUserUsageOverviewErrors[keyof GetUserUsageOverviewErrors];
4626
-
4627
4392
  export type GetUserUsageOverviewResponses = {
4628
4393
  /**
4629
4394
  * Successful Response
@@ -4635,12 +4400,6 @@ export type GetUserUsageOverviewResponse = GetUserUsageOverviewResponses[keyof G
4635
4400
 
4636
4401
  export type GetDetailedUserAnalyticsData = {
4637
4402
  body?: never;
4638
- headers?: {
4639
- /**
4640
- * Authorization
4641
- */
4642
- authorization?: string | null;
4643
- };
4644
4403
  path?: never;
4645
4404
  query?: {
4646
4405
  /**
@@ -4653,11 +4412,6 @@ export type GetDetailedUserAnalyticsData = {
4653
4412
  * Include recent activity
4654
4413
  */
4655
4414
  include_recent_activity?: boolean;
4656
- /**
4657
- * Token
4658
- * JWT token for SSE authentication
4659
- */
4660
- token?: string | null;
4661
4415
  };
4662
4416
  url: '/v1/user/analytics/detailed';
4663
4417
  };
@@ -4682,12 +4436,6 @@ export type GetDetailedUserAnalyticsResponse = GetDetailedUserAnalyticsResponses
4682
4436
 
4683
4437
  export type GetUserSharedSubscriptionsData = {
4684
4438
  body?: never;
4685
- headers?: {
4686
- /**
4687
- * Authorization
4688
- */
4689
- authorization?: string | null;
4690
- };
4691
4439
  path?: never;
4692
4440
  query?: {
4693
4441
  /**
@@ -4695,11 +4443,6 @@ export type GetUserSharedSubscriptionsData = {
4695
4443
  * Only return active subscriptions
4696
4444
  */
4697
4445
  active_only?: boolean;
4698
- /**
4699
- * Token
4700
- * JWT token for SSE authentication
4701
- */
4702
- token?: string | null;
4703
4446
  };
4704
4447
  url: '/v1/user/subscriptions/shared-repositories';
4705
4448
  };
@@ -4732,20 +4475,8 @@ export type GetUserSharedSubscriptionsResponse = GetUserSharedSubscriptionsRespo
4732
4475
 
4733
4476
  export type SubscribeToSharedRepositoryData = {
4734
4477
  body: SubscriptionRequest;
4735
- headers?: {
4736
- /**
4737
- * Authorization
4738
- */
4739
- authorization?: string | null;
4740
- };
4741
4478
  path?: never;
4742
- query?: {
4743
- /**
4744
- * Token
4745
- * JWT token for SSE authentication
4746
- */
4747
- token?: string | null;
4748
- };
4479
+ query?: never;
4749
4480
  url: '/v1/user/subscriptions/shared-repositories/subscribe';
4750
4481
  };
4751
4482
 
@@ -4781,25 +4512,13 @@ export type SubscribeToSharedRepositoryResponse = SubscribeToSharedRepositoryRes
4781
4512
 
4782
4513
  export type UpgradeSharedRepositorySubscriptionData = {
4783
4514
  body: TierUpgradeRequest;
4784
- headers?: {
4785
- /**
4786
- * Authorization
4787
- */
4788
- authorization?: string | null;
4789
- };
4790
4515
  path: {
4791
4516
  /**
4792
4517
  * Subscription Id
4793
4518
  */
4794
4519
  subscription_id: string;
4795
4520
  };
4796
- query?: {
4797
- /**
4798
- * Token
4799
- * JWT token for SSE authentication
4800
- */
4801
- token?: string | null;
4802
- };
4521
+ query?: never;
4803
4522
  url: '/v1/user/subscriptions/shared-repositories/{subscription_id}/upgrade';
4804
4523
  };
4805
4524
 
@@ -4837,25 +4556,13 @@ export type UpgradeSharedRepositorySubscriptionResponses = {
4837
4556
 
4838
4557
  export type CancelSharedRepositorySubscriptionData = {
4839
4558
  body?: never;
4840
- headers?: {
4841
- /**
4842
- * Authorization
4843
- */
4844
- authorization?: string | null;
4845
- };
4846
4559
  path: {
4847
4560
  /**
4848
4561
  * Subscription Id
4849
4562
  */
4850
4563
  subscription_id: string;
4851
4564
  };
4852
- query?: {
4853
- /**
4854
- * Token
4855
- * JWT token for SSE authentication
4856
- */
4857
- token?: string | null;
4858
- };
4565
+ query?: never;
4859
4566
  url: '/v1/user/subscriptions/shared-repositories/{subscription_id}';
4860
4567
  };
4861
4568
 
@@ -4891,20 +4598,8 @@ export type CancelSharedRepositorySubscriptionResponse = CancelSharedRepositoryS
4891
4598
 
4892
4599
  export type GetSharedRepositoryCreditsData = {
4893
4600
  body?: never;
4894
- headers?: {
4895
- /**
4896
- * Authorization
4897
- */
4898
- authorization?: string | null;
4899
- };
4900
4601
  path?: never;
4901
- query?: {
4902
- /**
4903
- * Token
4904
- * JWT token for SSE authentication
4905
- */
4906
- token?: string | null;
4907
- };
4602
+ query?: never;
4908
4603
  url: '/v1/user/subscriptions/shared-repositories/credits';
4909
4604
  };
4910
4605
 
@@ -4913,18 +4608,12 @@ export type GetSharedRepositoryCreditsErrors = {
4913
4608
  * Authentication required
4914
4609
  */
4915
4610
  401: unknown;
4916
- /**
4917
- * Validation Error
4918
- */
4919
- 422: HttpValidationError;
4920
4611
  /**
4921
4612
  * Internal server error
4922
4613
  */
4923
4614
  500: unknown;
4924
4615
  };
4925
4616
 
4926
- export type GetSharedRepositoryCreditsError = GetSharedRepositoryCreditsErrors[keyof GetSharedRepositoryCreditsErrors];
4927
-
4928
4617
  export type GetSharedRepositoryCreditsResponses = {
4929
4618
  /**
4930
4619
  * Successfully retrieved credit balances
@@ -4936,25 +4625,13 @@ export type GetSharedRepositoryCreditsResponse = GetSharedRepositoryCreditsRespo
4936
4625
 
4937
4626
  export type GetRepositoryCreditsData = {
4938
4627
  body?: never;
4939
- headers?: {
4940
- /**
4941
- * Authorization
4942
- */
4943
- authorization?: string | null;
4944
- };
4945
4628
  path: {
4946
4629
  /**
4947
4630
  * Repository
4948
4631
  */
4949
4632
  repository: string;
4950
4633
  };
4951
- query?: {
4952
- /**
4953
- * Token
4954
- * JWT token for SSE authentication
4955
- */
4956
- token?: string | null;
4957
- };
4634
+ query?: never;
4958
4635
  url: '/v1/user/subscriptions/shared-repositories/credits/{repository}';
4959
4636
  };
4960
4637
 
@@ -4986,16 +4663,9 @@ export type GetRepositoryCreditsResponse = GetRepositoryCreditsResponses[keyof G
4986
4663
 
4987
4664
  export type ListConnectionsData = {
4988
4665
  body?: never;
4989
- headers?: {
4990
- /**
4991
- * Authorization
4992
- */
4993
- authorization?: string | null;
4994
- };
4995
4666
  path: {
4996
4667
  /**
4997
4668
  * Graph Id
4998
- * Graph database identifier
4999
4669
  */
5000
4670
  graph_id: string;
5001
4671
  };
@@ -5010,11 +4680,6 @@ export type ListConnectionsData = {
5010
4680
  * Filter by provider type
5011
4681
  */
5012
4682
  provider?: ('sec' | 'quickbooks' | 'plaid') | null;
5013
- /**
5014
- * Token
5015
- * JWT token for SSE authentication
5016
- */
5017
- token?: string | null;
5018
4683
  };
5019
4684
  url: '/v1/graphs/{graph_id}/connections';
5020
4685
  };
@@ -5048,26 +4713,13 @@ export type ListConnectionsResponse = ListConnectionsResponses[keyof ListConnect
5048
4713
 
5049
4714
  export type CreateConnectionData = {
5050
4715
  body: CreateConnectionRequest;
5051
- headers?: {
5052
- /**
5053
- * Authorization
5054
- */
5055
- authorization?: string | null;
5056
- };
5057
4716
  path: {
5058
4717
  /**
5059
4718
  * Graph Id
5060
- * Graph database identifier
5061
4719
  */
5062
4720
  graph_id: string;
5063
4721
  };
5064
- query?: {
5065
- /**
5066
- * Token
5067
- * JWT token for SSE authentication
5068
- */
5069
- token?: string | null;
5070
- };
4722
+ query?: never;
5071
4723
  url: '/v1/graphs/{graph_id}/connections';
5072
4724
  };
5073
4725
 
@@ -5107,26 +4759,13 @@ export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateCon
5107
4759
 
5108
4760
  export type GetConnectionOptionsData = {
5109
4761
  body?: never;
5110
- headers?: {
5111
- /**
5112
- * Authorization
5113
- */
5114
- authorization?: string | null;
5115
- };
5116
4762
  path: {
5117
4763
  /**
5118
4764
  * Graph Id
5119
- * Graph database identifier
5120
4765
  */
5121
4766
  graph_id: string;
5122
4767
  };
5123
- query?: {
5124
- /**
5125
- * Token
5126
- * JWT token for SSE authentication
5127
- */
5128
- token?: string | null;
5129
- };
4768
+ query?: never;
5130
4769
  url: '/v1/graphs/{graph_id}/connections/options';
5131
4770
  };
5132
4771
 
@@ -5158,26 +4797,13 @@ export type GetConnectionOptionsResponse = GetConnectionOptionsResponses[keyof G
5158
4797
 
5159
4798
  export type ExchangeLinkTokenData = {
5160
4799
  body: ExchangeTokenRequest;
5161
- headers?: {
5162
- /**
5163
- * Authorization
5164
- */
5165
- authorization?: string | null;
5166
- };
5167
4800
  path: {
5168
4801
  /**
5169
4802
  * Graph Id
5170
- * Graph database identifier
5171
4803
  */
5172
4804
  graph_id: string;
5173
4805
  };
5174
- query?: {
5175
- /**
5176
- * Token
5177
- * JWT token for SSE authentication
5178
- */
5179
- token?: string | null;
5180
- };
4806
+ query?: never;
5181
4807
  url: '/v1/graphs/{graph_id}/connections/link/exchange';
5182
4808
  };
5183
4809
 
@@ -5211,26 +4837,13 @@ export type ExchangeLinkTokenResponses = {
5211
4837
 
5212
4838
  export type CreateLinkTokenData = {
5213
4839
  body: LinkTokenRequest;
5214
- headers?: {
5215
- /**
5216
- * Authorization
5217
- */
5218
- authorization?: string | null;
5219
- };
5220
4840
  path: {
5221
4841
  /**
5222
4842
  * Graph Id
5223
- * Graph database identifier
5224
4843
  */
5225
4844
  graph_id: string;
5226
4845
  };
5227
- query?: {
5228
- /**
5229
- * Token
5230
- * JWT token for SSE authentication
5231
- */
5232
- token?: string | null;
5233
- };
4846
+ query?: never;
5234
4847
  url: '/v1/graphs/{graph_id}/connections/link/token';
5235
4848
  };
5236
4849
 
@@ -5264,26 +4877,13 @@ export type CreateLinkTokenResponses = {
5264
4877
 
5265
4878
  export type InitOAuthData = {
5266
4879
  body: OAuthInitRequest;
5267
- headers?: {
5268
- /**
5269
- * Authorization
5270
- */
5271
- authorization?: string | null;
5272
- };
5273
4880
  path: {
5274
4881
  /**
5275
4882
  * Graph Id
5276
- * Graph database identifier
5277
4883
  */
5278
4884
  graph_id: string;
5279
4885
  };
5280
- query?: {
5281
- /**
5282
- * Token
5283
- * JWT token for SSE authentication
5284
- */
5285
- token?: string | null;
5286
- };
4886
+ query?: never;
5287
4887
  url: '/v1/graphs/{graph_id}/connections/oauth/init';
5288
4888
  };
5289
4889
 
@@ -5307,12 +4907,6 @@ export type InitOAuthResponse = InitOAuthResponses[keyof InitOAuthResponses];
5307
4907
 
5308
4908
  export type OauthCallbackData = {
5309
4909
  body: OAuthCallbackRequest;
5310
- headers?: {
5311
- /**
5312
- * Authorization
5313
- */
5314
- authorization?: string | null;
5315
- };
5316
4910
  path: {
5317
4911
  /**
5318
4912
  * Provider
@@ -5321,17 +4915,10 @@ export type OauthCallbackData = {
5321
4915
  provider: string;
5322
4916
  /**
5323
4917
  * Graph Id
5324
- * Graph database identifier
5325
4918
  */
5326
4919
  graph_id: string;
5327
4920
  };
5328
- query?: {
5329
- /**
5330
- * Token
5331
- * JWT token for SSE authentication
5332
- */
5333
- token?: string | null;
5334
- };
4921
+ query?: never;
5335
4922
  url: '/v1/graphs/{graph_id}/connections/oauth/callback/{provider}';
5336
4923
  };
5337
4924
 
@@ -5369,16 +4956,9 @@ export type OauthCallbackResponses = {
5369
4956
 
5370
4957
  export type DeleteConnectionData = {
5371
4958
  body?: never;
5372
- headers?: {
5373
- /**
5374
- * Authorization
5375
- */
5376
- authorization?: string | null;
5377
- };
5378
4959
  path: {
5379
4960
  /**
5380
4961
  * Graph Id
5381
- * Graph database identifier
5382
4962
  */
5383
4963
  graph_id: string;
5384
4964
  /**
@@ -5387,13 +4967,7 @@ export type DeleteConnectionData = {
5387
4967
  */
5388
4968
  connection_id: string;
5389
4969
  };
5390
- query?: {
5391
- /**
5392
- * Token
5393
- * JWT token for SSE authentication
5394
- */
5395
- token?: string | null;
5396
- };
4970
+ query?: never;
5397
4971
  url: '/v1/graphs/{graph_id}/connections/{connection_id}';
5398
4972
  };
5399
4973
 
@@ -5429,16 +5003,9 @@ export type DeleteConnectionResponse = DeleteConnectionResponses[keyof DeleteCon
5429
5003
 
5430
5004
  export type GetConnectionData = {
5431
5005
  body?: never;
5432
- headers?: {
5433
- /**
5434
- * Authorization
5435
- */
5436
- authorization?: string | null;
5437
- };
5438
5006
  path: {
5439
5007
  /**
5440
5008
  * Graph Id
5441
- * Graph database identifier
5442
5009
  */
5443
5010
  graph_id: string;
5444
5011
  /**
@@ -5447,13 +5014,7 @@ export type GetConnectionData = {
5447
5014
  */
5448
5015
  connection_id: string;
5449
5016
  };
5450
- query?: {
5451
- /**
5452
- * Token
5453
- * JWT token for SSE authentication
5454
- */
5455
- token?: string | null;
5456
- };
5017
+ query?: never;
5457
5018
  url: '/v1/graphs/{graph_id}/connections/{connection_id}';
5458
5019
  };
5459
5020
 
@@ -5489,16 +5050,9 @@ export type GetConnectionResponse = GetConnectionResponses[keyof GetConnectionRe
5489
5050
 
5490
5051
  export type SyncConnectionData = {
5491
5052
  body: SyncConnectionRequest;
5492
- headers?: {
5493
- /**
5494
- * Authorization
5495
- */
5496
- authorization?: string | null;
5497
- };
5498
5053
  path: {
5499
5054
  /**
5500
5055
  * Graph Id
5501
- * Graph database identifier
5502
5056
  */
5503
5057
  graph_id: string;
5504
5058
  /**
@@ -5507,13 +5061,7 @@ export type SyncConnectionData = {
5507
5061
  */
5508
5062
  connection_id: string;
5509
5063
  };
5510
- query?: {
5511
- /**
5512
- * Token
5513
- * JWT token for SSE authentication
5514
- */
5515
- token?: string | null;
5516
- };
5064
+ query?: never;
5517
5065
  url: '/v1/graphs/{graph_id}/connections/{connection_id}/sync';
5518
5066
  };
5519
5067
 
@@ -5552,25 +5100,13 @@ export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectio
5552
5100
 
5553
5101
  export type AutoSelectAgentData = {
5554
5102
  body: AgentRequest;
5555
- headers?: {
5556
- /**
5557
- * Authorization
5558
- */
5559
- authorization?: string | null;
5560
- };
5561
5103
  path: {
5562
5104
  /**
5563
5105
  * Graph Id
5564
5106
  */
5565
5107
  graph_id: string;
5566
5108
  };
5567
- query?: {
5568
- /**
5569
- * Token
5570
- * JWT token for SSE authentication
5571
- */
5572
- token?: string | null;
5573
- };
5109
+ query?: never;
5574
5110
  url: '/v1/graphs/{graph_id}/agent';
5575
5111
  };
5576
5112
 
@@ -5610,12 +5146,6 @@ export type AutoSelectAgentResponse = AutoSelectAgentResponses[keyof AutoSelectA
5610
5146
 
5611
5147
  export type ExecuteSpecificAgentData = {
5612
5148
  body: AgentRequest;
5613
- headers?: {
5614
- /**
5615
- * Authorization
5616
- */
5617
- authorization?: string | null;
5618
- };
5619
5149
  path: {
5620
5150
  /**
5621
5151
  * Agent Type
@@ -5626,13 +5156,7 @@ export type ExecuteSpecificAgentData = {
5626
5156
  */
5627
5157
  graph_id: string;
5628
5158
  };
5629
- query?: {
5630
- /**
5631
- * Token
5632
- * JWT token for SSE authentication
5633
- */
5634
- token?: string | null;
5635
- };
5159
+ query?: never;
5636
5160
  url: '/v1/graphs/{graph_id}/agent/{agent_type}';
5637
5161
  };
5638
5162
 
@@ -5676,25 +5200,13 @@ export type ExecuteSpecificAgentResponse = ExecuteSpecificAgentResponses[keyof E
5676
5200
 
5677
5201
  export type BatchProcessQueriesData = {
5678
5202
  body: BatchAgentRequest;
5679
- headers?: {
5680
- /**
5681
- * Authorization
5682
- */
5683
- authorization?: string | null;
5684
- };
5685
5203
  path: {
5686
5204
  /**
5687
5205
  * Graph Id
5688
5206
  */
5689
5207
  graph_id: string;
5690
5208
  };
5691
- query?: {
5692
- /**
5693
- * Token
5694
- * JWT token for SSE authentication
5695
- */
5696
- token?: string | null;
5697
- };
5209
+ query?: never;
5698
5210
  url: '/v1/graphs/{graph_id}/agent/batch';
5699
5211
  };
5700
5212
 
@@ -5730,16 +5242,9 @@ export type BatchProcessQueriesResponse = BatchProcessQueriesResponses[keyof Bat
5730
5242
 
5731
5243
  export type ListAgentsData = {
5732
5244
  body?: never;
5733
- headers?: {
5734
- /**
5735
- * Authorization
5736
- */
5737
- authorization?: string | null;
5738
- };
5739
5245
  path: {
5740
5246
  /**
5741
5247
  * Graph Id
5742
- * Graph database identifier
5743
5248
  */
5744
5249
  graph_id: string;
5745
5250
  };
@@ -5749,11 +5254,6 @@ export type ListAgentsData = {
5749
5254
  * Filter by capability (e.g., 'financial_analysis', 'rag_search')
5750
5255
  */
5751
5256
  capability?: string | null;
5752
- /**
5753
- * Token
5754
- * JWT token for SSE authentication
5755
- */
5756
- token?: string | null;
5757
5257
  };
5758
5258
  url: '/v1/graphs/{graph_id}/agent/list';
5759
5259
  };
@@ -5782,16 +5282,9 @@ export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
5782
5282
 
5783
5283
  export type GetAgentMetadataData = {
5784
5284
  body?: never;
5785
- headers?: {
5786
- /**
5787
- * Authorization
5788
- */
5789
- authorization?: string | null;
5790
- };
5791
5285
  path: {
5792
5286
  /**
5793
5287
  * Graph Id
5794
- * Graph database identifier
5795
5288
  */
5796
5289
  graph_id: string;
5797
5290
  /**
@@ -5800,13 +5293,7 @@ export type GetAgentMetadataData = {
5800
5293
  */
5801
5294
  agent_type: string;
5802
5295
  };
5803
- query?: {
5804
- /**
5805
- * Token
5806
- * JWT token for SSE authentication
5807
- */
5808
- token?: string | null;
5809
- };
5296
+ query?: never;
5810
5297
  url: '/v1/graphs/{graph_id}/agent/{agent_type}/metadata';
5811
5298
  };
5812
5299
 
@@ -5834,26 +5321,13 @@ export type GetAgentMetadataResponse = GetAgentMetadataResponses[keyof GetAgentM
5834
5321
 
5835
5322
  export type RecommendAgentData = {
5836
5323
  body: AgentRecommendationRequest;
5837
- headers?: {
5838
- /**
5839
- * Authorization
5840
- */
5841
- authorization?: string | null;
5842
- };
5843
5324
  path: {
5844
5325
  /**
5845
5326
  * Graph Id
5846
- * Graph database identifier
5847
5327
  */
5848
5328
  graph_id: string;
5849
5329
  };
5850
- query?: {
5851
- /**
5852
- * Token
5853
- * JWT token for SSE authentication
5854
- */
5855
- token?: string | null;
5856
- };
5330
+ query?: never;
5857
5331
  url: '/v1/graphs/{graph_id}/agent/recommend';
5858
5332
  };
5859
5333
 
@@ -5881,26 +5355,13 @@ export type RecommendAgentResponse = RecommendAgentResponses[keyof RecommendAgen
5881
5355
 
5882
5356
  export type ListMcpToolsData = {
5883
5357
  body?: never;
5884
- headers?: {
5885
- /**
5886
- * Authorization
5887
- */
5888
- authorization?: string | null;
5889
- };
5890
5358
  path: {
5891
5359
  /**
5892
5360
  * Graph Id
5893
- * Graph database identifier
5894
5361
  */
5895
5362
  graph_id: string;
5896
5363
  };
5897
- query?: {
5898
- /**
5899
- * Token
5900
- * JWT token for SSE authentication
5901
- */
5902
- token?: string | null;
5903
- };
5364
+ query?: never;
5904
5365
  url: '/v1/graphs/{graph_id}/mcp/tools';
5905
5366
  };
5906
5367
 
@@ -5932,16 +5393,9 @@ export type ListMcpToolsResponse = ListMcpToolsResponses[keyof ListMcpToolsRespo
5932
5393
 
5933
5394
  export type CallMcpToolData = {
5934
5395
  body: McpToolCall;
5935
- headers?: {
5936
- /**
5937
- * Authorization
5938
- */
5939
- authorization?: string | null;
5940
- };
5941
5396
  path: {
5942
5397
  /**
5943
5398
  * Graph Id
5944
- * Graph database identifier
5945
5399
  */
5946
5400
  graph_id: string;
5947
5401
  };
@@ -5956,11 +5410,6 @@ export type CallMcpToolData = {
5956
5410
  * Enable test mode for debugging
5957
5411
  */
5958
5412
  test_mode?: boolean;
5959
- /**
5960
- * Token
5961
- * JWT token for SSE authentication
5962
- */
5963
- token?: string | null;
5964
5413
  };
5965
5414
  url: '/v1/graphs/{graph_id}/mcp/call-tool';
5966
5415
  };
@@ -6015,16 +5464,9 @@ export type CallMcpToolResponses = {
6015
5464
 
6016
5465
  export type ListBackupsData = {
6017
5466
  body?: never;
6018
- headers?: {
6019
- /**
6020
- * Authorization
6021
- */
6022
- authorization?: string | null;
6023
- };
6024
5467
  path: {
6025
5468
  /**
6026
5469
  * Graph Id
6027
- * Graph database identifier
6028
5470
  */
6029
5471
  graph_id: string;
6030
5472
  };
@@ -6039,11 +5481,6 @@ export type ListBackupsData = {
6039
5481
  * Number of backups to skip
6040
5482
  */
6041
5483
  offset?: number;
6042
- /**
6043
- * Token
6044
- * JWT token for SSE authentication
6045
- */
6046
- token?: string | null;
6047
5484
  };
6048
5485
  url: '/v1/graphs/{graph_id}/backups';
6049
5486
  };
@@ -6068,26 +5505,13 @@ export type ListBackupsResponse = ListBackupsResponses[keyof ListBackupsResponse
6068
5505
 
6069
5506
  export type CreateBackupData = {
6070
5507
  body: BackupCreateRequest;
6071
- headers?: {
6072
- /**
6073
- * Authorization
6074
- */
6075
- authorization?: string | null;
6076
- };
6077
5508
  path: {
6078
5509
  /**
6079
5510
  * Graph Id
6080
- * Graph database identifier
6081
5511
  */
6082
5512
  graph_id: string;
6083
5513
  };
6084
- query?: {
6085
- /**
6086
- * Token
6087
- * JWT token for SSE authentication
6088
- */
6089
- token?: string | null;
6090
- };
5514
+ query?: never;
6091
5515
  url: '/v1/graphs/{graph_id}/backups';
6092
5516
  };
6093
5517
 
@@ -6125,12 +5549,6 @@ export type CreateBackupResponses = {
6125
5549
 
6126
5550
  export type GetBackupDownloadUrlData = {
6127
5551
  body?: never;
6128
- headers?: {
6129
- /**
6130
- * Authorization
6131
- */
6132
- authorization?: string | null;
6133
- };
6134
5552
  path: {
6135
5553
  /**
6136
5554
  * Backup Id
@@ -6139,7 +5557,6 @@ export type GetBackupDownloadUrlData = {
6139
5557
  backup_id: string;
6140
5558
  /**
6141
5559
  * Graph Id
6142
- * Graph database identifier
6143
5560
  */
6144
5561
  graph_id: string;
6145
5562
  };
@@ -6149,11 +5566,6 @@ export type GetBackupDownloadUrlData = {
6149
5566
  * URL expiration time in seconds
6150
5567
  */
6151
5568
  expires_in?: number;
6152
- /**
6153
- * Token
6154
- * JWT token for SSE authentication
6155
- */
6156
- token?: string | null;
6157
5569
  };
6158
5570
  url: '/v1/graphs/{graph_id}/backups/{backup_id}/download';
6159
5571
  };
@@ -6193,12 +5605,6 @@ export type GetBackupDownloadUrlResponse = GetBackupDownloadUrlResponses[keyof G
6193
5605
 
6194
5606
  export type RestoreBackupData = {
6195
5607
  body: BackupRestoreRequest;
6196
- headers?: {
6197
- /**
6198
- * Authorization
6199
- */
6200
- authorization?: string | null;
6201
- };
6202
5608
  path: {
6203
5609
  /**
6204
5610
  * Backup Id
@@ -6207,17 +5613,10 @@ export type RestoreBackupData = {
6207
5613
  backup_id: string;
6208
5614
  /**
6209
5615
  * Graph Id
6210
- * Graph database identifier
6211
5616
  */
6212
5617
  graph_id: string;
6213
5618
  };
6214
- query?: {
6215
- /**
6216
- * Token
6217
- * JWT token for SSE authentication
6218
- */
6219
- token?: string | null;
6220
- };
5619
+ query?: never;
6221
5620
  url: '/v1/graphs/{graph_id}/backups/{backup_id}/restore';
6222
5621
  };
6223
5622
 
@@ -6255,26 +5654,13 @@ export type RestoreBackupResponses = {
6255
5654
 
6256
5655
  export type GetBackupStatsData = {
6257
5656
  body?: never;
6258
- headers?: {
6259
- /**
6260
- * Authorization
6261
- */
6262
- authorization?: string | null;
6263
- };
6264
5657
  path: {
6265
5658
  /**
6266
5659
  * Graph Id
6267
- * Graph database identifier
6268
5660
  */
6269
5661
  graph_id: string;
6270
5662
  };
6271
- query?: {
6272
- /**
6273
- * Token
6274
- * JWT token for SSE authentication
6275
- */
6276
- token?: string | null;
6277
- };
5663
+ query?: never;
6278
5664
  url: '/v1/graphs/{graph_id}/backups/stats';
6279
5665
  };
6280
5666
 
@@ -6298,26 +5684,13 @@ export type GetBackupStatsResponse = GetBackupStatsResponses[keyof GetBackupStat
6298
5684
 
6299
5685
  export type GetGraphMetricsData = {
6300
5686
  body?: never;
6301
- headers?: {
6302
- /**
6303
- * Authorization
6304
- */
6305
- authorization?: string | null;
6306
- };
6307
5687
  path: {
6308
5688
  /**
6309
5689
  * Graph Id
6310
- * The graph ID to get metrics for
6311
5690
  */
6312
5691
  graph_id: string;
6313
5692
  };
6314
- query?: {
6315
- /**
6316
- * Token
6317
- * JWT token for SSE authentication
6318
- */
6319
- token?: string | null;
6320
- };
5693
+ query?: never;
6321
5694
  url: '/v1/graphs/{graph_id}/analytics';
6322
5695
  };
6323
5696
 
@@ -6353,30 +5726,18 @@ export type GetGraphMetricsResponse = GetGraphMetricsResponses[keyof GetGraphMet
6353
5726
 
6354
5727
  export type GetGraphUsageStatsData = {
6355
5728
  body?: never;
6356
- headers?: {
6357
- /**
6358
- * Authorization
6359
- */
6360
- authorization?: string | null;
6361
- };
6362
5729
  path: {
6363
5730
  /**
6364
5731
  * Graph Id
6365
- * The graph ID to get usage stats for
6366
5732
  */
6367
5733
  graph_id: string;
6368
5734
  };
6369
5735
  query?: {
6370
5736
  /**
6371
5737
  * Include Details
6372
- * Include detailed metrics (may be slower)
6373
- */
6374
- include_details?: boolean;
6375
- /**
6376
- * Token
6377
- * JWT token for SSE authentication
5738
+ * Include detailed metrics (may be slower)
6378
5739
  */
6379
- token?: string | null;
5740
+ include_details?: boolean;
6380
5741
  };
6381
5742
  url: '/v1/graphs/{graph_id}/analytics/usage';
6382
5743
  };
@@ -6409,16 +5770,9 @@ export type GetGraphUsageStatsResponse = GetGraphUsageStatsResponses[keyof GetGr
6409
5770
 
6410
5771
  export type ExecuteCypherQueryData = {
6411
5772
  body: CypherQueryRequest;
6412
- headers?: {
6413
- /**
6414
- * Authorization
6415
- */
6416
- authorization?: string | null;
6417
- };
6418
5773
  path: {
6419
5774
  /**
6420
5775
  * Graph Id
6421
- * Graph database identifier
6422
5776
  */
6423
5777
  graph_id: string;
6424
5778
  };
@@ -6432,17 +5786,12 @@ export type ExecuteCypherQueryData = {
6432
5786
  * Chunk Size
6433
5787
  * Rows per chunk for streaming
6434
5788
  */
6435
- chunk_size?: number;
5789
+ chunk_size?: number | null;
6436
5790
  /**
6437
5791
  * Test Mode
6438
5792
  * Enable test mode for better debugging
6439
5793
  */
6440
5794
  test_mode?: boolean;
6441
- /**
6442
- * Token
6443
- * JWT token for SSE authentication
6444
- */
6445
- token?: string | null;
6446
5795
  };
6447
5796
  url: '/v1/graphs/{graph_id}/query';
6448
5797
  };
@@ -6493,26 +5842,13 @@ export type ExecuteCypherQueryResponses = {
6493
5842
 
6494
5843
  export type GetGraphSchemaData = {
6495
5844
  body?: never;
6496
- headers?: {
6497
- /**
6498
- * Authorization
6499
- */
6500
- authorization?: string | null;
6501
- };
6502
5845
  path: {
6503
5846
  /**
6504
5847
  * Graph Id
6505
- * The graph database to get schema for
6506
5848
  */
6507
5849
  graph_id: string;
6508
5850
  };
6509
- query?: {
6510
- /**
6511
- * Token
6512
- * JWT token for SSE authentication
6513
- */
6514
- token?: string | null;
6515
- };
5851
+ query?: never;
6516
5852
  url: '/v1/graphs/{graph_id}/schema';
6517
5853
  };
6518
5854
 
@@ -6529,34 +5865,28 @@ export type GetGraphSchemaErrors = {
6529
5865
  * Failed to retrieve schema
6530
5866
  */
6531
5867
  500: unknown;
5868
+ /**
5869
+ * Schema operation timed out
5870
+ */
5871
+ 504: unknown;
6532
5872
  };
6533
5873
 
6534
5874
  export type GetGraphSchemaError = GetGraphSchemaErrors[keyof GetGraphSchemaErrors];
6535
5875
 
6536
5876
  export type GetGraphSchemaResponses = {
6537
5877
  /**
6538
- * Response Getgraphschema
6539
5878
  * Schema information retrieved successfully
6540
5879
  */
6541
- 200: {
6542
- [key: string]: unknown;
6543
- };
5880
+ 200: SchemaInfoResponse;
6544
5881
  };
6545
5882
 
6546
5883
  export type GetGraphSchemaResponse = GetGraphSchemaResponses[keyof GetGraphSchemaResponses];
6547
5884
 
6548
5885
  export type ExportGraphSchemaData = {
6549
5886
  body?: never;
6550
- headers?: {
6551
- /**
6552
- * Authorization
6553
- */
6554
- authorization?: string | null;
6555
- };
6556
5887
  path: {
6557
5888
  /**
6558
5889
  * Graph Id
6559
- * The graph ID to export schema from
6560
5890
  */
6561
5891
  graph_id: string;
6562
5892
  };
@@ -6568,30 +5898,37 @@ export type ExportGraphSchemaData = {
6568
5898
  format?: string;
6569
5899
  /**
6570
5900
  * Include Data Stats
6571
- * Include statistics about actual data in the graph
5901
+ * Include statistics about actual data in the graph (node counts, relationship counts)
6572
5902
  */
6573
5903
  include_data_stats?: boolean;
6574
- /**
6575
- * Token
6576
- * JWT token for SSE authentication
6577
- */
6578
- token?: string | null;
6579
5904
  };
6580
5905
  url: '/v1/graphs/{graph_id}/schema/export';
6581
5906
  };
6582
5907
 
6583
5908
  export type ExportGraphSchemaErrors = {
5909
+ /**
5910
+ * Access denied to graph
5911
+ */
5912
+ 403: unknown;
5913
+ /**
5914
+ * Schema not found for graph
5915
+ */
5916
+ 404: unknown;
6584
5917
  /**
6585
5918
  * Validation Error
6586
5919
  */
6587
5920
  422: HttpValidationError;
5921
+ /**
5922
+ * Failed to export schema
5923
+ */
5924
+ 500: unknown;
6588
5925
  };
6589
5926
 
6590
5927
  export type ExportGraphSchemaError = ExportGraphSchemaErrors[keyof ExportGraphSchemaErrors];
6591
5928
 
6592
5929
  export type ExportGraphSchemaResponses = {
6593
5930
  /**
6594
- * Successful Response
5931
+ * Schema exported successfully
6595
5932
  */
6596
5933
  200: SchemaExportResponse;
6597
5934
  };
@@ -6603,26 +5940,13 @@ export type ValidateSchemaData = {
6603
5940
  * Schema definition to validate
6604
5941
  */
6605
5942
  body: SchemaValidationRequest;
6606
- headers?: {
6607
- /**
6608
- * Authorization
6609
- */
6610
- authorization?: string | null;
6611
- };
6612
5943
  path: {
6613
5944
  /**
6614
5945
  * Graph Id
6615
- * Graph database identifier
6616
5946
  */
6617
5947
  graph_id: string;
6618
5948
  };
6619
- query?: {
6620
- /**
6621
- * Token
6622
- * JWT token for SSE authentication
6623
- */
6624
- token?: string | null;
6625
- };
5949
+ query?: never;
6626
5950
  url: '/v1/graphs/{graph_id}/schema/validate';
6627
5951
  };
6628
5952
 
@@ -6658,26 +5982,13 @@ export type ValidateSchemaResponse = ValidateSchemaResponses[keyof ValidateSchem
6658
5982
 
6659
5983
  export type GetCurrentGraphBillData = {
6660
5984
  body?: never;
6661
- headers?: {
6662
- /**
6663
- * Authorization
6664
- */
6665
- authorization?: string | null;
6666
- };
6667
5985
  path: {
6668
5986
  /**
6669
5987
  * Graph Id
6670
- * Graph database identifier
6671
5988
  */
6672
5989
  graph_id: string;
6673
5990
  };
6674
- query?: {
6675
- /**
6676
- * Token
6677
- * JWT token for SSE authentication
6678
- */
6679
- token?: string | null;
6680
- };
5991
+ query?: never;
6681
5992
  url: '/v1/graphs/{graph_id}/billing/current';
6682
5993
  };
6683
5994
 
@@ -6716,16 +6027,9 @@ export type GetCurrentGraphBillResponse = GetCurrentGraphBillResponses[keyof Get
6716
6027
 
6717
6028
  export type GetGraphUsageDetailsData = {
6718
6029
  body?: never;
6719
- headers?: {
6720
- /**
6721
- * Authorization
6722
- */
6723
- authorization?: string | null;
6724
- };
6725
6030
  path: {
6726
6031
  /**
6727
6032
  * Graph Id
6728
- * Graph database identifier
6729
6033
  */
6730
6034
  graph_id: string;
6731
6035
  };
@@ -6740,11 +6044,6 @@ export type GetGraphUsageDetailsData = {
6740
6044
  * Month (defaults to current)
6741
6045
  */
6742
6046
  month?: number | null;
6743
- /**
6744
- * Token
6745
- * JWT token for SSE authentication
6746
- */
6747
- token?: string | null;
6748
6047
  };
6749
6048
  url: '/v1/graphs/{graph_id}/billing/usage';
6750
6049
  };
@@ -6788,16 +6087,9 @@ export type GetGraphUsageDetailsResponse = GetGraphUsageDetailsResponses[keyof G
6788
6087
 
6789
6088
  export type GetGraphBillingHistoryData = {
6790
6089
  body?: never;
6791
- headers?: {
6792
- /**
6793
- * Authorization
6794
- */
6795
- authorization?: string | null;
6796
- };
6797
6090
  path: {
6798
6091
  /**
6799
6092
  * Graph Id
6800
- * Graph database identifier
6801
6093
  */
6802
6094
  graph_id: string;
6803
6095
  };
@@ -6807,11 +6099,6 @@ export type GetGraphBillingHistoryData = {
6807
6099
  * Number of months to retrieve (1-24)
6808
6100
  */
6809
6101
  months?: number;
6810
- /**
6811
- * Token
6812
- * JWT token for SSE authentication
6813
- */
6814
- token?: string | null;
6815
6102
  };
6816
6103
  url: '/v1/graphs/{graph_id}/billing/history';
6817
6104
  };
@@ -6851,12 +6138,6 @@ export type GetGraphBillingHistoryResponse = GetGraphBillingHistoryResponses[key
6851
6138
 
6852
6139
  export type GetGraphMonthlyBillData = {
6853
6140
  body?: never;
6854
- headers?: {
6855
- /**
6856
- * Authorization
6857
- */
6858
- authorization?: string | null;
6859
- };
6860
6141
  path: {
6861
6142
  /**
6862
6143
  * Year
@@ -6870,17 +6151,10 @@ export type GetGraphMonthlyBillData = {
6870
6151
  month: number;
6871
6152
  /**
6872
6153
  * Graph Id
6873
- * Graph database identifier
6874
6154
  */
6875
6155
  graph_id: string;
6876
6156
  };
6877
- query?: {
6878
- /**
6879
- * Token
6880
- * JWT token for SSE authentication
6881
- */
6882
- token?: string | null;
6883
- };
6157
+ query?: never;
6884
6158
  url: '/v1/graphs/{graph_id}/billing/history/{year}/{month}';
6885
6159
  };
6886
6160
 
@@ -6923,12 +6197,6 @@ export type GetGraphMonthlyBillResponse = GetGraphMonthlyBillResponses[keyof Get
6923
6197
 
6924
6198
  export type GetCreditSummaryData = {
6925
6199
  body?: never;
6926
- headers?: {
6927
- /**
6928
- * Authorization
6929
- */
6930
- authorization?: string | null;
6931
- };
6932
6200
  path: {
6933
6201
  /**
6934
6202
  * Graph Id
@@ -6936,13 +6204,7 @@ export type GetCreditSummaryData = {
6936
6204
  */
6937
6205
  graph_id: string;
6938
6206
  };
6939
- query?: {
6940
- /**
6941
- * Token
6942
- * JWT token for SSE authentication
6943
- */
6944
- token?: string | null;
6945
- };
6207
+ query?: never;
6946
6208
  url: '/v1/graphs/{graph_id}/credits/summary';
6947
6209
  };
6948
6210
 
@@ -6978,16 +6240,9 @@ export type GetCreditSummaryResponse = GetCreditSummaryResponses[keyof GetCredit
6978
6240
 
6979
6241
  export type ListCreditTransactionsData = {
6980
6242
  body?: never;
6981
- headers?: {
6982
- /**
6983
- * Authorization
6984
- */
6985
- authorization?: string | null;
6986
- };
6987
6243
  path: {
6988
6244
  /**
6989
6245
  * Graph Id
6990
- * Graph database identifier
6991
6246
  */
6992
6247
  graph_id: string;
6993
6248
  };
@@ -7022,11 +6277,6 @@ export type ListCreditTransactionsData = {
7022
6277
  * Number of transactions to skip
7023
6278
  */
7024
6279
  offset?: number;
7025
- /**
7026
- * Token
7027
- * JWT token for SSE authentication
7028
- */
7029
- token?: string | null;
7030
6280
  };
7031
6281
  url: '/v1/graphs/{graph_id}/credits/transactions';
7032
6282
  };
@@ -7063,12 +6313,6 @@ export type ListCreditTransactionsResponse = ListCreditTransactionsResponses[key
7063
6313
 
7064
6314
  export type CheckCreditBalanceData = {
7065
6315
  body?: never;
7066
- headers?: {
7067
- /**
7068
- * Authorization
7069
- */
7070
- authorization?: string | null;
7071
- };
7072
6316
  path: {
7073
6317
  /**
7074
6318
  * Graph Id
@@ -7087,11 +6331,6 @@ export type CheckCreditBalanceData = {
7087
6331
  * Custom base cost (uses default if not provided)
7088
6332
  */
7089
6333
  base_cost?: number | string | null;
7090
- /**
7091
- * Token
7092
- * JWT token for SSE authentication
7093
- */
7094
- token?: string | null;
7095
6334
  };
7096
6335
  url: '/v1/graphs/{graph_id}/credits/balance/check';
7097
6336
  };
@@ -7131,12 +6370,6 @@ export type CheckCreditBalanceResponse = CheckCreditBalanceResponses[keyof Check
7131
6370
 
7132
6371
  export type GetStorageUsageData = {
7133
6372
  body?: never;
7134
- headers?: {
7135
- /**
7136
- * Authorization
7137
- */
7138
- authorization?: string | null;
7139
- };
7140
6373
  path: {
7141
6374
  /**
7142
6375
  * Graph Id
@@ -7150,11 +6383,6 @@ export type GetStorageUsageData = {
7150
6383
  * Number of days of history to return
7151
6384
  */
7152
6385
  days?: number;
7153
- /**
7154
- * Token
7155
- * JWT token for SSE authentication
7156
- */
7157
- token?: string | null;
7158
6386
  };
7159
6387
  url: '/v1/graphs/{graph_id}/credits/storage/usage';
7160
6388
  };
@@ -7190,12 +6418,6 @@ export type GetStorageUsageResponse = GetStorageUsageResponses[keyof GetStorageU
7190
6418
 
7191
6419
  export type CheckStorageLimitsData = {
7192
6420
  body?: never;
7193
- headers?: {
7194
- /**
7195
- * Authorization
7196
- */
7197
- authorization?: string | null;
7198
- };
7199
6421
  path: {
7200
6422
  /**
7201
6423
  * Graph Id
@@ -7203,13 +6425,7 @@ export type CheckStorageLimitsData = {
7203
6425
  */
7204
6426
  graph_id: string;
7205
6427
  };
7206
- query?: {
7207
- /**
7208
- * Token
7209
- * JWT token for SSE authentication
7210
- */
7211
- token?: string | null;
7212
- };
6428
+ query?: never;
7213
6429
  url: '/v1/graphs/{graph_id}/credits/storage/limits';
7214
6430
  };
7215
6431
 
@@ -7245,26 +6461,13 @@ export type CheckStorageLimitsResponse = CheckStorageLimitsResponses[keyof Check
7245
6461
 
7246
6462
  export type GetDatabaseHealthData = {
7247
6463
  body?: never;
7248
- headers?: {
7249
- /**
7250
- * Authorization
7251
- */
7252
- authorization?: string | null;
7253
- };
7254
6464
  path: {
7255
6465
  /**
7256
6466
  * Graph Id
7257
- * Graph database identifier
7258
6467
  */
7259
6468
  graph_id: string;
7260
6469
  };
7261
- query?: {
7262
- /**
7263
- * Token
7264
- * JWT token for SSE authentication
7265
- */
7266
- token?: string | null;
7267
- };
6470
+ query?: never;
7268
6471
  url: '/v1/graphs/{graph_id}/health';
7269
6472
  };
7270
6473
 
@@ -7300,26 +6503,13 @@ export type GetDatabaseHealthResponse = GetDatabaseHealthResponses[keyof GetData
7300
6503
 
7301
6504
  export type GetDatabaseInfoData = {
7302
6505
  body?: never;
7303
- headers?: {
7304
- /**
7305
- * Authorization
7306
- */
7307
- authorization?: string | null;
7308
- };
7309
6506
  path: {
7310
6507
  /**
7311
6508
  * Graph Id
7312
- * Graph database identifier
7313
6509
  */
7314
6510
  graph_id: string;
7315
6511
  };
7316
- query?: {
7317
- /**
7318
- * Token
7319
- * JWT token for SSE authentication
7320
- */
7321
- token?: string | null;
7322
- };
6512
+ query?: never;
7323
6513
  url: '/v1/graphs/{graph_id}/info';
7324
6514
  };
7325
6515
 
@@ -7355,26 +6545,13 @@ export type GetDatabaseInfoResponse = GetDatabaseInfoResponses[keyof GetDatabase
7355
6545
 
7356
6546
  export type GetGraphLimitsData = {
7357
6547
  body?: never;
7358
- headers?: {
7359
- /**
7360
- * Authorization
7361
- */
7362
- authorization?: string | null;
7363
- };
7364
6548
  path: {
7365
6549
  /**
7366
6550
  * Graph Id
7367
- * Graph database identifier (user graph or shared repository)
7368
6551
  */
7369
6552
  graph_id: string;
7370
6553
  };
7371
- query?: {
7372
- /**
7373
- * Token
7374
- * JWT token for SSE authentication
7375
- */
7376
- token?: string | null;
7377
- };
6554
+ query?: never;
7378
6555
  url: '/v1/graphs/{graph_id}/limits';
7379
6556
  };
7380
6557
 
@@ -7413,26 +6590,13 @@ export type GetGraphLimitsResponse = GetGraphLimitsResponses[keyof GetGraphLimit
7413
6590
 
7414
6591
  export type ListSubgraphsData = {
7415
6592
  body?: never;
7416
- headers?: {
7417
- /**
7418
- * Authorization
7419
- */
7420
- authorization?: string | null;
7421
- };
7422
6593
  path: {
7423
6594
  /**
7424
6595
  * Graph Id
7425
- * Parent graph ID (e.g., 'kg1a2b3c4d5')
7426
6596
  */
7427
6597
  graph_id: string;
7428
6598
  };
7429
- query?: {
7430
- /**
7431
- * Token
7432
- * JWT token for SSE authentication
7433
- */
7434
- token?: string | null;
7435
- };
6599
+ query?: never;
7436
6600
  url: '/v1/graphs/{graph_id}/subgraphs';
7437
6601
  };
7438
6602
 
@@ -7451,31 +6615,18 @@ export type ListSubgraphsResponses = {
7451
6615
  */
7452
6616
  200: ListSubgraphsResponse;
7453
6617
  };
7454
-
7455
- export type ListSubgraphsResponse2 = ListSubgraphsResponses[keyof ListSubgraphsResponses];
7456
-
7457
- export type CreateSubgraphData = {
7458
- body: CreateSubgraphRequest;
7459
- headers?: {
7460
- /**
7461
- * Authorization
7462
- */
7463
- authorization?: string | null;
7464
- };
6618
+
6619
+ export type ListSubgraphsResponse2 = ListSubgraphsResponses[keyof ListSubgraphsResponses];
6620
+
6621
+ export type CreateSubgraphData = {
6622
+ body: CreateSubgraphRequest;
7465
6623
  path: {
7466
6624
  /**
7467
6625
  * Graph Id
7468
- * Parent graph ID (e.g., 'kg1a2b3c4d5')
7469
6626
  */
7470
6627
  graph_id: string;
7471
6628
  };
7472
- query?: {
7473
- /**
7474
- * Token
7475
- * JWT token for SSE authentication
7476
- */
7477
- token?: string | null;
7478
- };
6629
+ query?: never;
7479
6630
  url: '/v1/graphs/{graph_id}/subgraphs';
7480
6631
  };
7481
6632
 
@@ -7499,16 +6650,9 @@ export type CreateSubgraphResponse = CreateSubgraphResponses[keyof CreateSubgrap
7499
6650
 
7500
6651
  export type DeleteSubgraphData = {
7501
6652
  body: DeleteSubgraphRequest;
7502
- headers?: {
7503
- /**
7504
- * Authorization
7505
- */
7506
- authorization?: string | null;
7507
- };
7508
6653
  path: {
7509
6654
  /**
7510
6655
  * Graph Id
7511
- * Parent graph identifier
7512
6656
  */
7513
6657
  graph_id: string;
7514
6658
  /**
@@ -7517,13 +6661,7 @@ export type DeleteSubgraphData = {
7517
6661
  */
7518
6662
  subgraph_id: string;
7519
6663
  };
7520
- query?: {
7521
- /**
7522
- * Token
7523
- * JWT token for SSE authentication
7524
- */
7525
- token?: string | null;
7526
- };
6664
+ query?: never;
7527
6665
  url: '/v1/graphs/{graph_id}/subgraphs/{subgraph_id}';
7528
6666
  };
7529
6667
 
@@ -7571,16 +6709,9 @@ export type DeleteSubgraphResponse2 = DeleteSubgraphResponses[keyof DeleteSubgra
7571
6709
 
7572
6710
  export type GetSubgraphInfoData = {
7573
6711
  body?: never;
7574
- headers?: {
7575
- /**
7576
- * Authorization
7577
- */
7578
- authorization?: string | null;
7579
- };
7580
6712
  path: {
7581
6713
  /**
7582
6714
  * Graph Id
7583
- * Parent graph identifier
7584
6715
  */
7585
6716
  graph_id: string;
7586
6717
  /**
@@ -7589,13 +6720,7 @@ export type GetSubgraphInfoData = {
7589
6720
  */
7590
6721
  subgraph_id: string;
7591
6722
  };
7592
- query?: {
7593
- /**
7594
- * Token
7595
- * JWT token for SSE authentication
7596
- */
7597
- token?: string | null;
7598
- };
6723
+ query?: never;
7599
6724
  url: '/v1/graphs/{graph_id}/subgraphs/{subgraph_id}/info';
7600
6725
  };
7601
6726
 
@@ -7639,26 +6764,13 @@ export type GetSubgraphInfoResponse = GetSubgraphInfoResponses[keyof GetSubgraph
7639
6764
 
7640
6765
  export type GetSubgraphQuotaData = {
7641
6766
  body?: never;
7642
- headers?: {
7643
- /**
7644
- * Authorization
7645
- */
7646
- authorization?: string | null;
7647
- };
7648
6767
  path: {
7649
6768
  /**
7650
6769
  * Graph Id
7651
- * Parent graph identifier
7652
6770
  */
7653
6771
  graph_id: string;
7654
6772
  };
7655
- query?: {
7656
- /**
7657
- * Token
7658
- * JWT token for SSE authentication
7659
- */
7660
- token?: string | null;
7661
- };
6773
+ query?: never;
7662
6774
  url: '/v1/graphs/{graph_id}/subgraphs/quota';
7663
6775
  };
7664
6776
 
@@ -7698,26 +6810,13 @@ export type GetSubgraphQuotaResponse = GetSubgraphQuotaResponses[keyof GetSubgra
7698
6810
 
7699
6811
  export type ListTablesData = {
7700
6812
  body?: never;
7701
- headers?: {
7702
- /**
7703
- * Authorization
7704
- */
7705
- authorization?: string | null;
7706
- };
7707
6813
  path: {
7708
6814
  /**
7709
6815
  * Graph Id
7710
- * Graph database identifier
7711
6816
  */
7712
6817
  graph_id: string;
7713
6818
  };
7714
- query?: {
7715
- /**
7716
- * Token
7717
- * JWT token for SSE authentication
7718
- */
7719
- token?: string | null;
7720
- };
6819
+ query?: never;
7721
6820
  url: '/v1/graphs/{graph_id}/tables';
7722
6821
  };
7723
6822
 
@@ -7757,16 +6856,9 @@ export type ListTablesResponse = ListTablesResponses[keyof ListTablesResponses];
7757
6856
 
7758
6857
  export type ListTableFilesData = {
7759
6858
  body?: never;
7760
- headers?: {
7761
- /**
7762
- * Authorization
7763
- */
7764
- authorization?: string | null;
7765
- };
7766
6859
  path: {
7767
6860
  /**
7768
6861
  * Graph Id
7769
- * Graph database identifier
7770
6862
  */
7771
6863
  graph_id: string;
7772
6864
  /**
@@ -7775,13 +6867,7 @@ export type ListTableFilesData = {
7775
6867
  */
7776
6868
  table_name: string;
7777
6869
  };
7778
- query?: {
7779
- /**
7780
- * Token
7781
- * JWT token for SSE authentication
7782
- */
7783
- token?: string | null;
7784
- };
6870
+ query?: never;
7785
6871
  url: '/v1/graphs/{graph_id}/tables/{table_name}/files';
7786
6872
  };
7787
6873
 
@@ -7824,16 +6910,9 @@ export type GetUploadUrlData = {
7824
6910
  * Upload request
7825
6911
  */
7826
6912
  body: FileUploadRequest;
7827
- headers?: {
7828
- /**
7829
- * Authorization
7830
- */
7831
- authorization?: string | null;
7832
- };
7833
6913
  path: {
7834
6914
  /**
7835
6915
  * Graph Id
7836
- * Graph database identifier
7837
6916
  */
7838
6917
  graph_id: string;
7839
6918
  /**
@@ -7842,13 +6921,7 @@ export type GetUploadUrlData = {
7842
6921
  */
7843
6922
  table_name: string;
7844
6923
  };
7845
- query?: {
7846
- /**
7847
- * Token
7848
- * JWT token for SSE authentication
7849
- */
7850
- token?: string | null;
7851
- };
6924
+ query?: never;
7852
6925
  url: '/v1/graphs/{graph_id}/tables/{table_name}/files';
7853
6926
  };
7854
6927
 
@@ -7892,16 +6965,9 @@ export type GetUploadUrlResponse = GetUploadUrlResponses[keyof GetUploadUrlRespo
7892
6965
 
7893
6966
  export type DeleteFileData = {
7894
6967
  body?: never;
7895
- headers?: {
7896
- /**
7897
- * Authorization
7898
- */
7899
- authorization?: string | null;
7900
- };
7901
6968
  path: {
7902
6969
  /**
7903
6970
  * Graph Id
7904
- * Graph database identifier
7905
6971
  */
7906
6972
  graph_id: string;
7907
6973
  /**
@@ -7910,13 +6976,7 @@ export type DeleteFileData = {
7910
6976
  */
7911
6977
  file_id: string;
7912
6978
  };
7913
- query?: {
7914
- /**
7915
- * Token
7916
- * JWT token for SSE authentication
7917
- */
7918
- token?: string | null;
7919
- };
6979
+ query?: never;
7920
6980
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
7921
6981
  };
7922
6982
 
@@ -7956,16 +7016,9 @@ export type DeleteFileResponse2 = DeleteFileResponses[keyof DeleteFileResponses]
7956
7016
 
7957
7017
  export type GetFileInfoData = {
7958
7018
  body?: never;
7959
- headers?: {
7960
- /**
7961
- * Authorization
7962
- */
7963
- authorization?: string | null;
7964
- };
7965
7019
  path: {
7966
7020
  /**
7967
7021
  * Graph Id
7968
- * Graph database identifier
7969
7022
  */
7970
7023
  graph_id: string;
7971
7024
  /**
@@ -7974,13 +7027,7 @@ export type GetFileInfoData = {
7974
7027
  */
7975
7028
  file_id: string;
7976
7029
  };
7977
- query?: {
7978
- /**
7979
- * Token
7980
- * JWT token for SSE authentication
7981
- */
7982
- token?: string | null;
7983
- };
7030
+ query?: never;
7984
7031
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
7985
7032
  };
7986
7033
 
@@ -8019,16 +7066,9 @@ export type UpdateFileStatusData = {
8019
7066
  * Status update
8020
7067
  */
8021
7068
  body: FileStatusUpdate;
8022
- headers?: {
8023
- /**
8024
- * Authorization
8025
- */
8026
- authorization?: string | null;
8027
- };
8028
7069
  path: {
8029
7070
  /**
8030
7071
  * Graph Id
8031
- * Graph database identifier
8032
7072
  */
8033
7073
  graph_id: string;
8034
7074
  /**
@@ -8037,13 +7077,7 @@ export type UpdateFileStatusData = {
8037
7077
  */
8038
7078
  file_id: string;
8039
7079
  };
8040
- query?: {
8041
- /**
8042
- * Token
8043
- * JWT token for SSE authentication
8044
- */
8045
- token?: string | null;
8046
- };
7080
+ query?: never;
8047
7081
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
8048
7082
  };
8049
7083
 
@@ -8097,26 +7131,13 @@ export type IngestTablesData = {
8097
7131
  * Ingestion request
8098
7132
  */
8099
7133
  body: BulkIngestRequest;
8100
- headers?: {
8101
- /**
8102
- * Authorization
8103
- */
8104
- authorization?: string | null;
8105
- };
8106
7134
  path: {
8107
7135
  /**
8108
7136
  * Graph Id
8109
- * Graph database identifier
8110
7137
  */
8111
7138
  graph_id: string;
8112
7139
  };
8113
- query?: {
8114
- /**
8115
- * Token
8116
- * JWT token for SSE authentication
8117
- */
8118
- token?: string | null;
8119
- };
7140
+ query?: never;
8120
7141
  url: '/v1/graphs/{graph_id}/tables/ingest';
8121
7142
  };
8122
7143
 
@@ -8163,26 +7184,13 @@ export type QueryTablesData = {
8163
7184
  * SQL query request
8164
7185
  */
8165
7186
  body: TableQueryRequest;
8166
- headers?: {
8167
- /**
8168
- * Authorization
8169
- */
8170
- authorization?: string | null;
8171
- };
8172
7187
  path: {
8173
7188
  /**
8174
7189
  * Graph Id
8175
- * Graph database identifier
8176
7190
  */
8177
7191
  graph_id: string;
8178
7192
  };
8179
- query?: {
8180
- /**
8181
- * Token
8182
- * JWT token for SSE authentication
8183
- */
8184
- token?: string | null;
8185
- };
7193
+ query?: never;
8186
7194
  url: '/v1/graphs/{graph_id}/tables/query';
8187
7195
  };
8188
7196
 
@@ -8230,35 +7238,21 @@ export type QueryTablesResponse = QueryTablesResponses[keyof QueryTablesResponse
8230
7238
 
8231
7239
  export type GetGraphsData = {
8232
7240
  body?: never;
8233
- headers?: {
8234
- /**
8235
- * Authorization
8236
- */
8237
- authorization?: string | null;
8238
- };
8239
7241
  path?: never;
8240
- query?: {
8241
- /**
8242
- * Token
8243
- * JWT token for SSE authentication
8244
- */
8245
- token?: string | null;
8246
- };
7242
+ query?: never;
8247
7243
  url: '/v1/graphs';
8248
7244
  };
8249
7245
 
8250
7246
  export type GetGraphsErrors = {
8251
7247
  /**
8252
- * Validation Error
7248
+ * Error retrieving graphs
8253
7249
  */
8254
- 422: HttpValidationError;
7250
+ 500: unknown;
8255
7251
  };
8256
7252
 
8257
- export type GetGraphsError = GetGraphsErrors[keyof GetGraphsErrors];
8258
-
8259
7253
  export type GetGraphsResponses = {
8260
7254
  /**
8261
- * Successful Response
7255
+ * Graphs retrieved successfully
8262
7256
  */
8263
7257
  200: UserGraphsResponse;
8264
7258
  };
@@ -8267,20 +7261,8 @@ export type GetGraphsResponse = GetGraphsResponses[keyof GetGraphsResponses];
8267
7261
 
8268
7262
  export type CreateGraphData = {
8269
7263
  body: CreateGraphRequest;
8270
- headers?: {
8271
- /**
8272
- * Authorization
8273
- */
8274
- authorization?: string | null;
8275
- };
8276
7264
  path?: never;
8277
- query?: {
8278
- /**
8279
- * Token
8280
- * JWT token for SSE authentication
8281
- */
8282
- token?: string | null;
8283
- };
7265
+ query?: never;
8284
7266
  url: '/v1/graphs';
8285
7267
  };
8286
7268
 
@@ -8307,9 +7289,16 @@ export type GetAvailableExtensionsData = {
8307
7289
  url: '/v1/graphs/extensions';
8308
7290
  };
8309
7291
 
7292
+ export type GetAvailableExtensionsErrors = {
7293
+ /**
7294
+ * Failed to retrieve extensions
7295
+ */
7296
+ 500: unknown;
7297
+ };
7298
+
8310
7299
  export type GetAvailableExtensionsResponses = {
8311
7300
  /**
8312
- * Successful Response
7301
+ * Extensions retrieved successfully
8313
7302
  */
8314
7303
  200: AvailableExtensionsResponse;
8315
7304
  };
@@ -8318,25 +7307,13 @@ export type GetAvailableExtensionsResponse = GetAvailableExtensionsResponses[key
8318
7307
 
8319
7308
  export type SelectGraphData = {
8320
7309
  body?: never;
8321
- headers?: {
8322
- /**
8323
- * Authorization
8324
- */
8325
- authorization?: string | null;
8326
- };
8327
7310
  path: {
8328
7311
  /**
8329
7312
  * Graph Id
8330
7313
  */
8331
7314
  graph_id: string;
8332
7315
  };
8333
- query?: {
8334
- /**
8335
- * Token
8336
- * JWT token for SSE authentication
8337
- */
8338
- token?: string | null;
8339
- };
7316
+ query?: never;
8340
7317
  url: '/v1/graphs/{graph_id}/select';
8341
7318
  };
8342
7319
 
@@ -8453,12 +7430,6 @@ export type StreamOperationEventsResponses = {
8453
7430
 
8454
7431
  export type GetOperationStatusData = {
8455
7432
  body?: never;
8456
- headers?: {
8457
- /**
8458
- * Authorization
8459
- */
8460
- authorization?: string | null;
8461
- };
8462
7433
  path: {
8463
7434
  /**
8464
7435
  * Operation Id
@@ -8466,13 +7437,7 @@ export type GetOperationStatusData = {
8466
7437
  */
8467
7438
  operation_id: string;
8468
7439
  };
8469
- query?: {
8470
- /**
8471
- * Token
8472
- * JWT token for SSE authentication
8473
- */
8474
- token?: string | null;
8475
- };
7440
+ query?: never;
8476
7441
  url: '/v1/operations/{operation_id}/status';
8477
7442
  };
8478
7443
 
@@ -8511,12 +7476,6 @@ export type GetOperationStatusResponse = GetOperationStatusResponses[keyof GetOp
8511
7476
 
8512
7477
  export type CancelOperationData = {
8513
7478
  body?: never;
8514
- headers?: {
8515
- /**
8516
- * Authorization
8517
- */
8518
- authorization?: string | null;
8519
- };
8520
7479
  path: {
8521
7480
  /**
8522
7481
  * Operation Id
@@ -8524,13 +7483,7 @@ export type CancelOperationData = {
8524
7483
  */
8525
7484
  operation_id: string;
8526
7485
  };
8527
- query?: {
8528
- /**
8529
- * Token
8530
- * JWT token for SSE authentication
8531
- */
8532
- token?: string | null;
8533
- };
7486
+ query?: never;
8534
7487
  url: '/v1/operations/{operation_id}';
8535
7488
  };
8536
7489