@robosystems/client 0.2.2 → 0.2.4

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/sdk/types.gen.ts CHANGED
@@ -433,6 +433,16 @@ export type AuthResponse = {
433
433
  * JWT authentication token (optional for cookie-based auth)
434
434
  */
435
435
  token?: string | null;
436
+ /**
437
+ * Expires In
438
+ * Token expiry time in seconds from now
439
+ */
440
+ expires_in?: number | null;
441
+ /**
442
+ * Refresh Threshold
443
+ * Recommended refresh threshold in seconds before expiry
444
+ */
445
+ refresh_threshold?: number | null;
436
446
  };
437
447
 
438
448
  /**
@@ -1231,12 +1241,12 @@ export type CustomSchemaDefinition = {
1231
1241
  export type CypherQueryRequest = {
1232
1242
  /**
1233
1243
  * Query
1234
- * The Cypher query to execute
1244
+ * The Cypher query to execute. Use parameters ($param_name) for all dynamic values to prevent injection attacks.
1235
1245
  */
1236
1246
  query: string;
1237
1247
  /**
1238
1248
  * Parameters
1239
- * Optional parameters for the Cypher query
1249
+ * Query parameters for safe value substitution. ALWAYS use parameters instead of string interpolation.
1240
1250
  */
1241
1251
  parameters?: {
1242
1252
  [key: string]: unknown;
@@ -2623,7 +2633,7 @@ export type SchemaExportResponse = {
2623
2633
  graph_id: string;
2624
2634
  /**
2625
2635
  * Schema Definition
2626
- * Exported schema definition
2636
+ * Exported schema definition (format depends on 'format' parameter)
2627
2637
  */
2628
2638
  schema_definition: {
2629
2639
  [key: string]: unknown;
@@ -2640,13 +2650,35 @@ export type SchemaExportResponse = {
2640
2650
  exported_at: string;
2641
2651
  /**
2642
2652
  * Data Stats
2643
- * Data statistics if requested
2653
+ * Data statistics if requested (only when include_data_stats=true)
2644
2654
  */
2645
2655
  data_stats?: {
2646
2656
  [key: string]: unknown;
2647
2657
  } | null;
2648
2658
  };
2649
2659
 
2660
+ /**
2661
+ * SchemaInfoResponse
2662
+ * Response model for runtime schema introspection.
2663
+ *
2664
+ * This model represents the actual current state of the graph database,
2665
+ * showing what node labels, relationship types, and properties exist right now.
2666
+ */
2667
+ export type SchemaInfoResponse = {
2668
+ /**
2669
+ * Graph Id
2670
+ * Graph database identifier
2671
+ */
2672
+ graph_id: string;
2673
+ /**
2674
+ * Schema
2675
+ * Runtime schema information showing actual database structure
2676
+ */
2677
+ schema: {
2678
+ [key: string]: unknown;
2679
+ };
2680
+ };
2681
+
2650
2682
  /**
2651
2683
  * SchemaValidationRequest
2652
2684
  * Request model for schema validation.
@@ -2688,24 +2720,24 @@ export type SchemaValidationResponse = {
2688
2720
  message: string;
2689
2721
  /**
2690
2722
  * Errors
2691
- * List of validation errors
2723
+ * List of validation errors (only present when valid=false)
2692
2724
  */
2693
2725
  errors?: Array<string> | null;
2694
2726
  /**
2695
2727
  * Warnings
2696
- * List of warnings
2728
+ * List of validation warnings (schema is still valid but has potential issues)
2697
2729
  */
2698
2730
  warnings?: Array<string> | null;
2699
2731
  /**
2700
2732
  * Stats
2701
- * Schema statistics (nodes, relationships, properties)
2733
+ * Schema statistics (only present when valid=true)
2702
2734
  */
2703
2735
  stats?: {
2704
2736
  [key: string]: number;
2705
2737
  } | null;
2706
2738
  /**
2707
2739
  * Compatibility
2708
- * Compatibility check results if requested
2740
+ * Compatibility check results (only when check_compatibility specified)
2709
2741
  */
2710
2742
  compatibility?: {
2711
2743
  [key: string]: unknown;
@@ -3180,9 +3212,14 @@ export type TableListResponse = {
3180
3212
  export type TableQueryRequest = {
3181
3213
  /**
3182
3214
  * Sql
3183
- * SQL query to execute on staging tables
3215
+ * SQL query to execute on staging tables. Use ? placeholders or $param_name for dynamic values to prevent SQL injection.
3184
3216
  */
3185
3217
  sql: string;
3218
+ /**
3219
+ * Parameters
3220
+ * Query parameters for safe value substitution. ALWAYS use parameters instead of string concatenation.
3221
+ */
3222
+ parameters?: Array<unknown> | null;
3186
3223
  };
3187
3224
 
3188
3225
  /**
@@ -3659,26 +3696,11 @@ export type LoginUserResponse = LoginUserResponses[keyof LoginUserResponses];
3659
3696
 
3660
3697
  export type LogoutUserData = {
3661
3698
  body?: never;
3662
- headers?: {
3663
- /**
3664
- * Authorization
3665
- */
3666
- authorization?: string | null;
3667
- };
3668
3699
  path?: never;
3669
3700
  query?: never;
3670
3701
  url: '/v1/auth/logout';
3671
3702
  };
3672
3703
 
3673
- export type LogoutUserErrors = {
3674
- /**
3675
- * Validation Error
3676
- */
3677
- 422: HttpValidationError;
3678
- };
3679
-
3680
- export type LogoutUserError = LogoutUserErrors[keyof LogoutUserErrors];
3681
-
3682
3704
  export type LogoutUserResponses = {
3683
3705
  /**
3684
3706
  * Response Logoutuser
@@ -3693,12 +3715,6 @@ export type LogoutUserResponse = LogoutUserResponses[keyof LogoutUserResponses];
3693
3715
 
3694
3716
  export type GetCurrentAuthUserData = {
3695
3717
  body?: never;
3696
- headers?: {
3697
- /**
3698
- * Authorization
3699
- */
3700
- authorization?: string | null;
3701
- };
3702
3718
  path?: never;
3703
3719
  query?: never;
3704
3720
  url: '/v1/auth/me';
@@ -3709,10 +3725,6 @@ export type GetCurrentAuthUserErrors = {
3709
3725
  * Not authenticated
3710
3726
  */
3711
3727
  401: ErrorResponse;
3712
- /**
3713
- * Validation Error
3714
- */
3715
- 422: HttpValidationError;
3716
3728
  };
3717
3729
 
3718
3730
  export type GetCurrentAuthUserError = GetCurrentAuthUserErrors[keyof GetCurrentAuthUserErrors];
@@ -3731,12 +3743,6 @@ export type GetCurrentAuthUserResponse = GetCurrentAuthUserResponses[keyof GetCu
3731
3743
 
3732
3744
  export type RefreshAuthSessionData = {
3733
3745
  body?: never;
3734
- headers?: {
3735
- /**
3736
- * Authorization
3737
- */
3738
- authorization?: string | null;
3739
- };
3740
3746
  path?: never;
3741
3747
  query?: never;
3742
3748
  url: '/v1/auth/refresh';
@@ -3747,10 +3753,6 @@ export type RefreshAuthSessionErrors = {
3747
3753
  * Not authenticated
3748
3754
  */
3749
3755
  401: ErrorResponse;
3750
- /**
3751
- * Validation Error
3752
- */
3753
- 422: HttpValidationError;
3754
3756
  };
3755
3757
 
3756
3758
  export type RefreshAuthSessionError = RefreshAuthSessionErrors[keyof RefreshAuthSessionErrors];
@@ -3766,12 +3768,6 @@ export type RefreshAuthSessionResponse = RefreshAuthSessionResponses[keyof Refre
3766
3768
 
3767
3769
  export type ResendVerificationEmailData = {
3768
3770
  body?: never;
3769
- headers?: {
3770
- /**
3771
- * Authorization
3772
- */
3773
- authorization?: string | null;
3774
- };
3775
3771
  path?: never;
3776
3772
  query?: never;
3777
3773
  url: '/v1/auth/email/resend';
@@ -3782,10 +3778,6 @@ export type ResendVerificationEmailErrors = {
3782
3778
  * Email already verified
3783
3779
  */
3784
3780
  400: ErrorResponse;
3785
- /**
3786
- * Validation Error
3787
- */
3788
- 422: HttpValidationError;
3789
3781
  /**
3790
3782
  * Rate limit exceeded
3791
3783
  */
@@ -3974,12 +3966,6 @@ export type ResetPasswordResponse = ResetPasswordResponses[keyof ResetPasswordRe
3974
3966
 
3975
3967
  export type GenerateSsoTokenData = {
3976
3968
  body?: never;
3977
- headers?: {
3978
- /**
3979
- * Authorization
3980
- */
3981
- authorization?: string | null;
3982
- };
3983
3969
  path?: never;
3984
3970
  query?: never;
3985
3971
  url: '/v1/auth/sso-token';
@@ -4101,32 +4087,11 @@ export type GetServiceStatusResponse = GetServiceStatusResponses[keyof GetServic
4101
4087
 
4102
4088
  export type GetCurrentUserData = {
4103
4089
  body?: never;
4104
- headers?: {
4105
- /**
4106
- * Authorization
4107
- */
4108
- authorization?: string | null;
4109
- };
4110
4090
  path?: never;
4111
- query?: {
4112
- /**
4113
- * Token
4114
- * JWT token for SSE authentication
4115
- */
4116
- token?: string | null;
4117
- };
4091
+ query?: never;
4118
4092
  url: '/v1/user';
4119
4093
  };
4120
4094
 
4121
- export type GetCurrentUserErrors = {
4122
- /**
4123
- * Validation Error
4124
- */
4125
- 422: HttpValidationError;
4126
- };
4127
-
4128
- export type GetCurrentUserError = GetCurrentUserErrors[keyof GetCurrentUserErrors];
4129
-
4130
4095
  export type GetCurrentUserResponses = {
4131
4096
  /**
4132
4097
  * Successful Response
@@ -4138,20 +4103,8 @@ export type GetCurrentUserResponse = GetCurrentUserResponses[keyof GetCurrentUse
4138
4103
 
4139
4104
  export type UpdateUserData = {
4140
4105
  body: UpdateUserRequest;
4141
- headers?: {
4142
- /**
4143
- * Authorization
4144
- */
4145
- authorization?: string | null;
4146
- };
4147
4106
  path?: never;
4148
- query?: {
4149
- /**
4150
- * Token
4151
- * JWT token for SSE authentication
4152
- */
4153
- token?: string | null;
4154
- };
4107
+ query?: never;
4155
4108
  url: '/v1/user';
4156
4109
  };
4157
4110
 
@@ -4175,28 +4128,12 @@ export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
4175
4128
 
4176
4129
  export type GetAllCreditSummariesData = {
4177
4130
  body?: never;
4178
- headers?: {
4179
- /**
4180
- * Authorization
4181
- */
4182
- authorization?: string | null;
4183
- };
4184
4131
  path?: never;
4185
- query?: {
4186
- /**
4187
- * Token
4188
- * JWT token for SSE authentication
4189
- */
4190
- token?: string | null;
4191
- };
4132
+ query?: never;
4192
4133
  url: '/v1/user/credits';
4193
4134
  };
4194
4135
 
4195
4136
  export type GetAllCreditSummariesErrors = {
4196
- /**
4197
- * Validation Error
4198
- */
4199
- 422: HttpValidationError;
4200
4137
  /**
4201
4138
  * Failed to retrieve credit summaries
4202
4139
  */
@@ -4219,20 +4156,8 @@ export type GetAllCreditSummariesResponse = GetAllCreditSummariesResponses[keyof
4219
4156
 
4220
4157
  export type UpdateUserPasswordData = {
4221
4158
  body: UpdatePasswordRequest;
4222
- headers?: {
4223
- /**
4224
- * Authorization
4225
- */
4226
- authorization?: string | null;
4227
- };
4228
4159
  path?: never;
4229
- query?: {
4230
- /**
4231
- * Token
4232
- * JWT token for SSE authentication
4233
- */
4234
- token?: string | null;
4235
- };
4160
+ query?: never;
4236
4161
  url: '/v1/user/password';
4237
4162
  };
4238
4163
 
@@ -4268,32 +4193,11 @@ export type UpdateUserPasswordResponse = UpdateUserPasswordResponses[keyof Updat
4268
4193
 
4269
4194
  export type ListUserApiKeysData = {
4270
4195
  body?: never;
4271
- headers?: {
4272
- /**
4273
- * Authorization
4274
- */
4275
- authorization?: string | null;
4276
- };
4277
4196
  path?: never;
4278
- query?: {
4279
- /**
4280
- * Token
4281
- * JWT token for SSE authentication
4282
- */
4283
- token?: string | null;
4284
- };
4197
+ query?: never;
4285
4198
  url: '/v1/user/api-keys';
4286
4199
  };
4287
4200
 
4288
- export type ListUserApiKeysErrors = {
4289
- /**
4290
- * Validation Error
4291
- */
4292
- 422: HttpValidationError;
4293
- };
4294
-
4295
- export type ListUserApiKeysError = ListUserApiKeysErrors[keyof ListUserApiKeysErrors];
4296
-
4297
4201
  export type ListUserApiKeysResponses = {
4298
4202
  /**
4299
4203
  * Successful Response
@@ -4305,20 +4209,8 @@ export type ListUserApiKeysResponse = ListUserApiKeysResponses[keyof ListUserApi
4305
4209
 
4306
4210
  export type CreateUserApiKeyData = {
4307
4211
  body: CreateApiKeyRequest;
4308
- headers?: {
4309
- /**
4310
- * Authorization
4311
- */
4312
- authorization?: string | null;
4313
- };
4314
4212
  path?: never;
4315
- query?: {
4316
- /**
4317
- * Token
4318
- * JWT token for SSE authentication
4319
- */
4320
- token?: string | null;
4321
- };
4213
+ query?: never;
4322
4214
  url: '/v1/user/api-keys';
4323
4215
  };
4324
4216
 
@@ -4342,25 +4234,13 @@ export type CreateUserApiKeyResponse = CreateUserApiKeyResponses[keyof CreateUse
4342
4234
 
4343
4235
  export type RevokeUserApiKeyData = {
4344
4236
  body?: never;
4345
- headers?: {
4346
- /**
4347
- * Authorization
4348
- */
4349
- authorization?: string | null;
4350
- };
4351
4237
  path: {
4352
4238
  /**
4353
4239
  * Api Key Id
4354
4240
  */
4355
4241
  api_key_id: string;
4356
4242
  };
4357
- query?: {
4358
- /**
4359
- * Token
4360
- * JWT token for SSE authentication
4361
- */
4362
- token?: string | null;
4363
- };
4243
+ query?: never;
4364
4244
  url: '/v1/user/api-keys/{api_key_id}';
4365
4245
  };
4366
4246
 
@@ -4392,25 +4272,13 @@ export type RevokeUserApiKeyResponse = RevokeUserApiKeyResponses[keyof RevokeUse
4392
4272
 
4393
4273
  export type UpdateUserApiKeyData = {
4394
4274
  body: UpdateApiKeyRequest;
4395
- headers?: {
4396
- /**
4397
- * Authorization
4398
- */
4399
- authorization?: string | null;
4400
- };
4401
4275
  path: {
4402
4276
  /**
4403
4277
  * Api Key Id
4404
4278
  */
4405
4279
  api_key_id: string;
4406
4280
  };
4407
- query?: {
4408
- /**
4409
- * Token
4410
- * JWT token for SSE authentication
4411
- */
4412
- token?: string | null;
4413
- };
4281
+ query?: never;
4414
4282
  url: '/v1/user/api-keys/{api_key_id}';
4415
4283
  };
4416
4284
 
@@ -4434,20 +4302,8 @@ export type UpdateUserApiKeyResponse = UpdateUserApiKeyResponses[keyof UpdateUse
4434
4302
 
4435
4303
  export type GetUserLimitsData = {
4436
4304
  body?: never;
4437
- headers?: {
4438
- /**
4439
- * Authorization
4440
- */
4441
- authorization?: string | null;
4442
- };
4443
4305
  path?: never;
4444
- query?: {
4445
- /**
4446
- * Token
4447
- * JWT token for SSE authentication
4448
- */
4449
- token?: string | null;
4450
- };
4306
+ query?: never;
4451
4307
  url: '/v1/user/limits';
4452
4308
  };
4453
4309
 
@@ -4456,14 +4312,8 @@ export type GetUserLimitsErrors = {
4456
4312
  * User limits not found
4457
4313
  */
4458
4314
  404: unknown;
4459
- /**
4460
- * Validation Error
4461
- */
4462
- 422: HttpValidationError;
4463
4315
  };
4464
4316
 
4465
- export type GetUserLimitsError = GetUserLimitsErrors[keyof GetUserLimitsErrors];
4466
-
4467
4317
  export type GetUserLimitsResponses = {
4468
4318
  /**
4469
4319
  * User limits retrieved successfully
@@ -4475,32 +4325,11 @@ export type GetUserLimitsResponse = GetUserLimitsResponses[keyof GetUserLimitsRe
4475
4325
 
4476
4326
  export type GetUserUsageData = {
4477
4327
  body?: never;
4478
- headers?: {
4479
- /**
4480
- * Authorization
4481
- */
4482
- authorization?: string | null;
4483
- };
4484
4328
  path?: never;
4485
- query?: {
4486
- /**
4487
- * Token
4488
- * JWT token for SSE authentication
4489
- */
4490
- token?: string | null;
4491
- };
4329
+ query?: never;
4492
4330
  url: '/v1/user/limits/usage';
4493
4331
  };
4494
4332
 
4495
- export type GetUserUsageErrors = {
4496
- /**
4497
- * Validation Error
4498
- */
4499
- 422: HttpValidationError;
4500
- };
4501
-
4502
- export type GetUserUsageError = GetUserUsageErrors[keyof GetUserUsageErrors];
4503
-
4504
4333
  export type GetUserUsageResponses = {
4505
4334
  /**
4506
4335
  * User usage statistics retrieved successfully
@@ -4512,33 +4341,12 @@ export type GetUserUsageResponse = GetUserUsageResponses[keyof GetUserUsageRespo
4512
4341
 
4513
4342
  export type GetAllSharedRepositoryLimitsData = {
4514
4343
  body?: never;
4515
- headers?: {
4516
- /**
4517
- * Authorization
4518
- */
4519
- authorization?: string | null;
4520
- };
4521
4344
  path?: never;
4522
- query?: {
4523
- /**
4524
- * Token
4525
- * JWT token for SSE authentication
4526
- */
4527
- token?: string | null;
4528
- };
4345
+ query?: never;
4529
4346
  url: '/v1/user/limits/shared-repositories/summary';
4530
4347
  };
4531
4348
 
4532
- export type GetAllSharedRepositoryLimitsErrors = {
4533
- /**
4534
- * Validation Error
4535
- */
4536
- 422: HttpValidationError;
4537
- };
4538
-
4539
- export type GetAllSharedRepositoryLimitsError = GetAllSharedRepositoryLimitsErrors[keyof GetAllSharedRepositoryLimitsErrors];
4540
-
4541
- export type GetAllSharedRepositoryLimitsResponses = {
4349
+ export type GetAllSharedRepositoryLimitsResponses = {
4542
4350
  /**
4543
4351
  * Response Getallsharedrepositorylimits
4544
4352
  * Successful Response
@@ -4552,12 +4360,6 @@ export type GetAllSharedRepositoryLimitsResponse = GetAllSharedRepositoryLimitsR
4552
4360
 
4553
4361
  export type GetSharedRepositoryLimitsData = {
4554
4362
  body?: never;
4555
- headers?: {
4556
- /**
4557
- * Authorization
4558
- */
4559
- authorization?: string | null;
4560
- };
4561
4363
  path: {
4562
4364
  /**
4563
4365
  * Repository
@@ -4565,13 +4367,7 @@ export type GetSharedRepositoryLimitsData = {
4565
4367
  */
4566
4368
  repository: string;
4567
4369
  };
4568
- query?: {
4569
- /**
4570
- * Token
4571
- * JWT token for SSE authentication
4572
- */
4573
- token?: string | null;
4574
- };
4370
+ query?: never;
4575
4371
  url: '/v1/user/limits/shared-repositories/{repository}';
4576
4372
  };
4577
4373
 
@@ -4598,32 +4394,11 @@ export type GetSharedRepositoryLimitsResponse = GetSharedRepositoryLimitsRespons
4598
4394
 
4599
4395
  export type GetUserUsageOverviewData = {
4600
4396
  body?: never;
4601
- headers?: {
4602
- /**
4603
- * Authorization
4604
- */
4605
- authorization?: string | null;
4606
- };
4607
4397
  path?: never;
4608
- query?: {
4609
- /**
4610
- * Token
4611
- * JWT token for SSE authentication
4612
- */
4613
- token?: string | null;
4614
- };
4398
+ query?: never;
4615
4399
  url: '/v1/user/analytics/overview';
4616
4400
  };
4617
4401
 
4618
- export type GetUserUsageOverviewErrors = {
4619
- /**
4620
- * Validation Error
4621
- */
4622
- 422: HttpValidationError;
4623
- };
4624
-
4625
- export type GetUserUsageOverviewError = GetUserUsageOverviewErrors[keyof GetUserUsageOverviewErrors];
4626
-
4627
4402
  export type GetUserUsageOverviewResponses = {
4628
4403
  /**
4629
4404
  * Successful Response
@@ -4635,12 +4410,6 @@ export type GetUserUsageOverviewResponse = GetUserUsageOverviewResponses[keyof G
4635
4410
 
4636
4411
  export type GetDetailedUserAnalyticsData = {
4637
4412
  body?: never;
4638
- headers?: {
4639
- /**
4640
- * Authorization
4641
- */
4642
- authorization?: string | null;
4643
- };
4644
4413
  path?: never;
4645
4414
  query?: {
4646
4415
  /**
@@ -4653,11 +4422,6 @@ export type GetDetailedUserAnalyticsData = {
4653
4422
  * Include recent activity
4654
4423
  */
4655
4424
  include_recent_activity?: boolean;
4656
- /**
4657
- * Token
4658
- * JWT token for SSE authentication
4659
- */
4660
- token?: string | null;
4661
4425
  };
4662
4426
  url: '/v1/user/analytics/detailed';
4663
4427
  };
@@ -4682,12 +4446,6 @@ export type GetDetailedUserAnalyticsResponse = GetDetailedUserAnalyticsResponses
4682
4446
 
4683
4447
  export type GetUserSharedSubscriptionsData = {
4684
4448
  body?: never;
4685
- headers?: {
4686
- /**
4687
- * Authorization
4688
- */
4689
- authorization?: string | null;
4690
- };
4691
4449
  path?: never;
4692
4450
  query?: {
4693
4451
  /**
@@ -4695,11 +4453,6 @@ export type GetUserSharedSubscriptionsData = {
4695
4453
  * Only return active subscriptions
4696
4454
  */
4697
4455
  active_only?: boolean;
4698
- /**
4699
- * Token
4700
- * JWT token for SSE authentication
4701
- */
4702
- token?: string | null;
4703
4456
  };
4704
4457
  url: '/v1/user/subscriptions/shared-repositories';
4705
4458
  };
@@ -4732,20 +4485,8 @@ export type GetUserSharedSubscriptionsResponse = GetUserSharedSubscriptionsRespo
4732
4485
 
4733
4486
  export type SubscribeToSharedRepositoryData = {
4734
4487
  body: SubscriptionRequest;
4735
- headers?: {
4736
- /**
4737
- * Authorization
4738
- */
4739
- authorization?: string | null;
4740
- };
4741
4488
  path?: never;
4742
- query?: {
4743
- /**
4744
- * Token
4745
- * JWT token for SSE authentication
4746
- */
4747
- token?: string | null;
4748
- };
4489
+ query?: never;
4749
4490
  url: '/v1/user/subscriptions/shared-repositories/subscribe';
4750
4491
  };
4751
4492
 
@@ -4781,25 +4522,13 @@ export type SubscribeToSharedRepositoryResponse = SubscribeToSharedRepositoryRes
4781
4522
 
4782
4523
  export type UpgradeSharedRepositorySubscriptionData = {
4783
4524
  body: TierUpgradeRequest;
4784
- headers?: {
4785
- /**
4786
- * Authorization
4787
- */
4788
- authorization?: string | null;
4789
- };
4790
4525
  path: {
4791
4526
  /**
4792
4527
  * Subscription Id
4793
4528
  */
4794
4529
  subscription_id: string;
4795
4530
  };
4796
- query?: {
4797
- /**
4798
- * Token
4799
- * JWT token for SSE authentication
4800
- */
4801
- token?: string | null;
4802
- };
4531
+ query?: never;
4803
4532
  url: '/v1/user/subscriptions/shared-repositories/{subscription_id}/upgrade';
4804
4533
  };
4805
4534
 
@@ -4837,25 +4566,13 @@ export type UpgradeSharedRepositorySubscriptionResponses = {
4837
4566
 
4838
4567
  export type CancelSharedRepositorySubscriptionData = {
4839
4568
  body?: never;
4840
- headers?: {
4841
- /**
4842
- * Authorization
4843
- */
4844
- authorization?: string | null;
4845
- };
4846
4569
  path: {
4847
4570
  /**
4848
4571
  * Subscription Id
4849
4572
  */
4850
4573
  subscription_id: string;
4851
4574
  };
4852
- query?: {
4853
- /**
4854
- * Token
4855
- * JWT token for SSE authentication
4856
- */
4857
- token?: string | null;
4858
- };
4575
+ query?: never;
4859
4576
  url: '/v1/user/subscriptions/shared-repositories/{subscription_id}';
4860
4577
  };
4861
4578
 
@@ -4891,20 +4608,8 @@ export type CancelSharedRepositorySubscriptionResponse = CancelSharedRepositoryS
4891
4608
 
4892
4609
  export type GetSharedRepositoryCreditsData = {
4893
4610
  body?: never;
4894
- headers?: {
4895
- /**
4896
- * Authorization
4897
- */
4898
- authorization?: string | null;
4899
- };
4900
4611
  path?: never;
4901
- query?: {
4902
- /**
4903
- * Token
4904
- * JWT token for SSE authentication
4905
- */
4906
- token?: string | null;
4907
- };
4612
+ query?: never;
4908
4613
  url: '/v1/user/subscriptions/shared-repositories/credits';
4909
4614
  };
4910
4615
 
@@ -4913,18 +4618,12 @@ export type GetSharedRepositoryCreditsErrors = {
4913
4618
  * Authentication required
4914
4619
  */
4915
4620
  401: unknown;
4916
- /**
4917
- * Validation Error
4918
- */
4919
- 422: HttpValidationError;
4920
4621
  /**
4921
4622
  * Internal server error
4922
4623
  */
4923
4624
  500: unknown;
4924
4625
  };
4925
4626
 
4926
- export type GetSharedRepositoryCreditsError = GetSharedRepositoryCreditsErrors[keyof GetSharedRepositoryCreditsErrors];
4927
-
4928
4627
  export type GetSharedRepositoryCreditsResponses = {
4929
4628
  /**
4930
4629
  * Successfully retrieved credit balances
@@ -4936,25 +4635,13 @@ export type GetSharedRepositoryCreditsResponse = GetSharedRepositoryCreditsRespo
4936
4635
 
4937
4636
  export type GetRepositoryCreditsData = {
4938
4637
  body?: never;
4939
- headers?: {
4940
- /**
4941
- * Authorization
4942
- */
4943
- authorization?: string | null;
4944
- };
4945
4638
  path: {
4946
4639
  /**
4947
4640
  * Repository
4948
4641
  */
4949
4642
  repository: string;
4950
4643
  };
4951
- query?: {
4952
- /**
4953
- * Token
4954
- * JWT token for SSE authentication
4955
- */
4956
- token?: string | null;
4957
- };
4644
+ query?: never;
4958
4645
  url: '/v1/user/subscriptions/shared-repositories/credits/{repository}';
4959
4646
  };
4960
4647
 
@@ -4986,16 +4673,9 @@ export type GetRepositoryCreditsResponse = GetRepositoryCreditsResponses[keyof G
4986
4673
 
4987
4674
  export type ListConnectionsData = {
4988
4675
  body?: never;
4989
- headers?: {
4990
- /**
4991
- * Authorization
4992
- */
4993
- authorization?: string | null;
4994
- };
4995
4676
  path: {
4996
4677
  /**
4997
4678
  * Graph Id
4998
- * Graph database identifier
4999
4679
  */
5000
4680
  graph_id: string;
5001
4681
  };
@@ -5010,11 +4690,6 @@ export type ListConnectionsData = {
5010
4690
  * Filter by provider type
5011
4691
  */
5012
4692
  provider?: ('sec' | 'quickbooks' | 'plaid') | null;
5013
- /**
5014
- * Token
5015
- * JWT token for SSE authentication
5016
- */
5017
- token?: string | null;
5018
4693
  };
5019
4694
  url: '/v1/graphs/{graph_id}/connections';
5020
4695
  };
@@ -5048,26 +4723,13 @@ export type ListConnectionsResponse = ListConnectionsResponses[keyof ListConnect
5048
4723
 
5049
4724
  export type CreateConnectionData = {
5050
4725
  body: CreateConnectionRequest;
5051
- headers?: {
5052
- /**
5053
- * Authorization
5054
- */
5055
- authorization?: string | null;
5056
- };
5057
4726
  path: {
5058
4727
  /**
5059
4728
  * Graph Id
5060
- * Graph database identifier
5061
4729
  */
5062
4730
  graph_id: string;
5063
4731
  };
5064
- query?: {
5065
- /**
5066
- * Token
5067
- * JWT token for SSE authentication
5068
- */
5069
- token?: string | null;
5070
- };
4732
+ query?: never;
5071
4733
  url: '/v1/graphs/{graph_id}/connections';
5072
4734
  };
5073
4735
 
@@ -5107,26 +4769,13 @@ export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateCon
5107
4769
 
5108
4770
  export type GetConnectionOptionsData = {
5109
4771
  body?: never;
5110
- headers?: {
5111
- /**
5112
- * Authorization
5113
- */
5114
- authorization?: string | null;
5115
- };
5116
4772
  path: {
5117
4773
  /**
5118
4774
  * Graph Id
5119
- * Graph database identifier
5120
4775
  */
5121
4776
  graph_id: string;
5122
4777
  };
5123
- query?: {
5124
- /**
5125
- * Token
5126
- * JWT token for SSE authentication
5127
- */
5128
- token?: string | null;
5129
- };
4778
+ query?: never;
5130
4779
  url: '/v1/graphs/{graph_id}/connections/options';
5131
4780
  };
5132
4781
 
@@ -5158,26 +4807,13 @@ export type GetConnectionOptionsResponse = GetConnectionOptionsResponses[keyof G
5158
4807
 
5159
4808
  export type ExchangeLinkTokenData = {
5160
4809
  body: ExchangeTokenRequest;
5161
- headers?: {
5162
- /**
5163
- * Authorization
5164
- */
5165
- authorization?: string | null;
5166
- };
5167
4810
  path: {
5168
4811
  /**
5169
4812
  * Graph Id
5170
- * Graph database identifier
5171
4813
  */
5172
4814
  graph_id: string;
5173
4815
  };
5174
- query?: {
5175
- /**
5176
- * Token
5177
- * JWT token for SSE authentication
5178
- */
5179
- token?: string | null;
5180
- };
4816
+ query?: never;
5181
4817
  url: '/v1/graphs/{graph_id}/connections/link/exchange';
5182
4818
  };
5183
4819
 
@@ -5211,26 +4847,13 @@ export type ExchangeLinkTokenResponses = {
5211
4847
 
5212
4848
  export type CreateLinkTokenData = {
5213
4849
  body: LinkTokenRequest;
5214
- headers?: {
5215
- /**
5216
- * Authorization
5217
- */
5218
- authorization?: string | null;
5219
- };
5220
4850
  path: {
5221
4851
  /**
5222
4852
  * Graph Id
5223
- * Graph database identifier
5224
4853
  */
5225
4854
  graph_id: string;
5226
4855
  };
5227
- query?: {
5228
- /**
5229
- * Token
5230
- * JWT token for SSE authentication
5231
- */
5232
- token?: string | null;
5233
- };
4856
+ query?: never;
5234
4857
  url: '/v1/graphs/{graph_id}/connections/link/token';
5235
4858
  };
5236
4859
 
@@ -5264,26 +4887,13 @@ export type CreateLinkTokenResponses = {
5264
4887
 
5265
4888
  export type InitOAuthData = {
5266
4889
  body: OAuthInitRequest;
5267
- headers?: {
5268
- /**
5269
- * Authorization
5270
- */
5271
- authorization?: string | null;
5272
- };
5273
4890
  path: {
5274
4891
  /**
5275
4892
  * Graph Id
5276
- * Graph database identifier
5277
4893
  */
5278
4894
  graph_id: string;
5279
4895
  };
5280
- query?: {
5281
- /**
5282
- * Token
5283
- * JWT token for SSE authentication
5284
- */
5285
- token?: string | null;
5286
- };
4896
+ query?: never;
5287
4897
  url: '/v1/graphs/{graph_id}/connections/oauth/init';
5288
4898
  };
5289
4899
 
@@ -5307,12 +4917,6 @@ export type InitOAuthResponse = InitOAuthResponses[keyof InitOAuthResponses];
5307
4917
 
5308
4918
  export type OauthCallbackData = {
5309
4919
  body: OAuthCallbackRequest;
5310
- headers?: {
5311
- /**
5312
- * Authorization
5313
- */
5314
- authorization?: string | null;
5315
- };
5316
4920
  path: {
5317
4921
  /**
5318
4922
  * Provider
@@ -5321,17 +4925,10 @@ export type OauthCallbackData = {
5321
4925
  provider: string;
5322
4926
  /**
5323
4927
  * Graph Id
5324
- * Graph database identifier
5325
4928
  */
5326
4929
  graph_id: string;
5327
4930
  };
5328
- query?: {
5329
- /**
5330
- * Token
5331
- * JWT token for SSE authentication
5332
- */
5333
- token?: string | null;
5334
- };
4931
+ query?: never;
5335
4932
  url: '/v1/graphs/{graph_id}/connections/oauth/callback/{provider}';
5336
4933
  };
5337
4934
 
@@ -5369,16 +4966,9 @@ export type OauthCallbackResponses = {
5369
4966
 
5370
4967
  export type DeleteConnectionData = {
5371
4968
  body?: never;
5372
- headers?: {
5373
- /**
5374
- * Authorization
5375
- */
5376
- authorization?: string | null;
5377
- };
5378
4969
  path: {
5379
4970
  /**
5380
4971
  * Graph Id
5381
- * Graph database identifier
5382
4972
  */
5383
4973
  graph_id: string;
5384
4974
  /**
@@ -5387,13 +4977,7 @@ export type DeleteConnectionData = {
5387
4977
  */
5388
4978
  connection_id: string;
5389
4979
  };
5390
- query?: {
5391
- /**
5392
- * Token
5393
- * JWT token for SSE authentication
5394
- */
5395
- token?: string | null;
5396
- };
4980
+ query?: never;
5397
4981
  url: '/v1/graphs/{graph_id}/connections/{connection_id}';
5398
4982
  };
5399
4983
 
@@ -5429,16 +5013,9 @@ export type DeleteConnectionResponse = DeleteConnectionResponses[keyof DeleteCon
5429
5013
 
5430
5014
  export type GetConnectionData = {
5431
5015
  body?: never;
5432
- headers?: {
5433
- /**
5434
- * Authorization
5435
- */
5436
- authorization?: string | null;
5437
- };
5438
5016
  path: {
5439
5017
  /**
5440
5018
  * Graph Id
5441
- * Graph database identifier
5442
5019
  */
5443
5020
  graph_id: string;
5444
5021
  /**
@@ -5447,13 +5024,7 @@ export type GetConnectionData = {
5447
5024
  */
5448
5025
  connection_id: string;
5449
5026
  };
5450
- query?: {
5451
- /**
5452
- * Token
5453
- * JWT token for SSE authentication
5454
- */
5455
- token?: string | null;
5456
- };
5027
+ query?: never;
5457
5028
  url: '/v1/graphs/{graph_id}/connections/{connection_id}';
5458
5029
  };
5459
5030
 
@@ -5489,16 +5060,9 @@ export type GetConnectionResponse = GetConnectionResponses[keyof GetConnectionRe
5489
5060
 
5490
5061
  export type SyncConnectionData = {
5491
5062
  body: SyncConnectionRequest;
5492
- headers?: {
5493
- /**
5494
- * Authorization
5495
- */
5496
- authorization?: string | null;
5497
- };
5498
5063
  path: {
5499
5064
  /**
5500
5065
  * Graph Id
5501
- * Graph database identifier
5502
5066
  */
5503
5067
  graph_id: string;
5504
5068
  /**
@@ -5507,13 +5071,7 @@ export type SyncConnectionData = {
5507
5071
  */
5508
5072
  connection_id: string;
5509
5073
  };
5510
- query?: {
5511
- /**
5512
- * Token
5513
- * JWT token for SSE authentication
5514
- */
5515
- token?: string | null;
5516
- };
5074
+ query?: never;
5517
5075
  url: '/v1/graphs/{graph_id}/connections/{connection_id}/sync';
5518
5076
  };
5519
5077
 
@@ -5552,25 +5110,13 @@ export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectio
5552
5110
 
5553
5111
  export type AutoSelectAgentData = {
5554
5112
  body: AgentRequest;
5555
- headers?: {
5556
- /**
5557
- * Authorization
5558
- */
5559
- authorization?: string | null;
5560
- };
5561
5113
  path: {
5562
5114
  /**
5563
5115
  * Graph Id
5564
5116
  */
5565
5117
  graph_id: string;
5566
5118
  };
5567
- query?: {
5568
- /**
5569
- * Token
5570
- * JWT token for SSE authentication
5571
- */
5572
- token?: string | null;
5573
- };
5119
+ query?: never;
5574
5120
  url: '/v1/graphs/{graph_id}/agent';
5575
5121
  };
5576
5122
 
@@ -5610,12 +5156,6 @@ export type AutoSelectAgentResponse = AutoSelectAgentResponses[keyof AutoSelectA
5610
5156
 
5611
5157
  export type ExecuteSpecificAgentData = {
5612
5158
  body: AgentRequest;
5613
- headers?: {
5614
- /**
5615
- * Authorization
5616
- */
5617
- authorization?: string | null;
5618
- };
5619
5159
  path: {
5620
5160
  /**
5621
5161
  * Agent Type
@@ -5626,13 +5166,7 @@ export type ExecuteSpecificAgentData = {
5626
5166
  */
5627
5167
  graph_id: string;
5628
5168
  };
5629
- query?: {
5630
- /**
5631
- * Token
5632
- * JWT token for SSE authentication
5633
- */
5634
- token?: string | null;
5635
- };
5169
+ query?: never;
5636
5170
  url: '/v1/graphs/{graph_id}/agent/{agent_type}';
5637
5171
  };
5638
5172
 
@@ -5676,25 +5210,13 @@ export type ExecuteSpecificAgentResponse = ExecuteSpecificAgentResponses[keyof E
5676
5210
 
5677
5211
  export type BatchProcessQueriesData = {
5678
5212
  body: BatchAgentRequest;
5679
- headers?: {
5680
- /**
5681
- * Authorization
5682
- */
5683
- authorization?: string | null;
5684
- };
5685
5213
  path: {
5686
5214
  /**
5687
5215
  * Graph Id
5688
5216
  */
5689
5217
  graph_id: string;
5690
5218
  };
5691
- query?: {
5692
- /**
5693
- * Token
5694
- * JWT token for SSE authentication
5695
- */
5696
- token?: string | null;
5697
- };
5219
+ query?: never;
5698
5220
  url: '/v1/graphs/{graph_id}/agent/batch';
5699
5221
  };
5700
5222
 
@@ -5730,16 +5252,9 @@ export type BatchProcessQueriesResponse = BatchProcessQueriesResponses[keyof Bat
5730
5252
 
5731
5253
  export type ListAgentsData = {
5732
5254
  body?: never;
5733
- headers?: {
5734
- /**
5735
- * Authorization
5736
- */
5737
- authorization?: string | null;
5738
- };
5739
5255
  path: {
5740
5256
  /**
5741
5257
  * Graph Id
5742
- * Graph database identifier
5743
5258
  */
5744
5259
  graph_id: string;
5745
5260
  };
@@ -5749,11 +5264,6 @@ export type ListAgentsData = {
5749
5264
  * Filter by capability (e.g., 'financial_analysis', 'rag_search')
5750
5265
  */
5751
5266
  capability?: string | null;
5752
- /**
5753
- * Token
5754
- * JWT token for SSE authentication
5755
- */
5756
- token?: string | null;
5757
5267
  };
5758
5268
  url: '/v1/graphs/{graph_id}/agent/list';
5759
5269
  };
@@ -5782,16 +5292,9 @@ export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
5782
5292
 
5783
5293
  export type GetAgentMetadataData = {
5784
5294
  body?: never;
5785
- headers?: {
5786
- /**
5787
- * Authorization
5788
- */
5789
- authorization?: string | null;
5790
- };
5791
5295
  path: {
5792
5296
  /**
5793
5297
  * Graph Id
5794
- * Graph database identifier
5795
5298
  */
5796
5299
  graph_id: string;
5797
5300
  /**
@@ -5800,13 +5303,7 @@ export type GetAgentMetadataData = {
5800
5303
  */
5801
5304
  agent_type: string;
5802
5305
  };
5803
- query?: {
5804
- /**
5805
- * Token
5806
- * JWT token for SSE authentication
5807
- */
5808
- token?: string | null;
5809
- };
5306
+ query?: never;
5810
5307
  url: '/v1/graphs/{graph_id}/agent/{agent_type}/metadata';
5811
5308
  };
5812
5309
 
@@ -5834,26 +5331,13 @@ export type GetAgentMetadataResponse = GetAgentMetadataResponses[keyof GetAgentM
5834
5331
 
5835
5332
  export type RecommendAgentData = {
5836
5333
  body: AgentRecommendationRequest;
5837
- headers?: {
5838
- /**
5839
- * Authorization
5840
- */
5841
- authorization?: string | null;
5842
- };
5843
5334
  path: {
5844
5335
  /**
5845
5336
  * Graph Id
5846
- * Graph database identifier
5847
5337
  */
5848
5338
  graph_id: string;
5849
5339
  };
5850
- query?: {
5851
- /**
5852
- * Token
5853
- * JWT token for SSE authentication
5854
- */
5855
- token?: string | null;
5856
- };
5340
+ query?: never;
5857
5341
  url: '/v1/graphs/{graph_id}/agent/recommend';
5858
5342
  };
5859
5343
 
@@ -5881,26 +5365,13 @@ export type RecommendAgentResponse = RecommendAgentResponses[keyof RecommendAgen
5881
5365
 
5882
5366
  export type ListMcpToolsData = {
5883
5367
  body?: never;
5884
- headers?: {
5885
- /**
5886
- * Authorization
5887
- */
5888
- authorization?: string | null;
5889
- };
5890
5368
  path: {
5891
5369
  /**
5892
5370
  * Graph Id
5893
- * Graph database identifier
5894
5371
  */
5895
5372
  graph_id: string;
5896
5373
  };
5897
- query?: {
5898
- /**
5899
- * Token
5900
- * JWT token for SSE authentication
5901
- */
5902
- token?: string | null;
5903
- };
5374
+ query?: never;
5904
5375
  url: '/v1/graphs/{graph_id}/mcp/tools';
5905
5376
  };
5906
5377
 
@@ -5932,16 +5403,9 @@ export type ListMcpToolsResponse = ListMcpToolsResponses[keyof ListMcpToolsRespo
5932
5403
 
5933
5404
  export type CallMcpToolData = {
5934
5405
  body: McpToolCall;
5935
- headers?: {
5936
- /**
5937
- * Authorization
5938
- */
5939
- authorization?: string | null;
5940
- };
5941
5406
  path: {
5942
5407
  /**
5943
5408
  * Graph Id
5944
- * Graph database identifier
5945
5409
  */
5946
5410
  graph_id: string;
5947
5411
  };
@@ -5956,11 +5420,6 @@ export type CallMcpToolData = {
5956
5420
  * Enable test mode for debugging
5957
5421
  */
5958
5422
  test_mode?: boolean;
5959
- /**
5960
- * Token
5961
- * JWT token for SSE authentication
5962
- */
5963
- token?: string | null;
5964
5423
  };
5965
5424
  url: '/v1/graphs/{graph_id}/mcp/call-tool';
5966
5425
  };
@@ -6015,16 +5474,9 @@ export type CallMcpToolResponses = {
6015
5474
 
6016
5475
  export type ListBackupsData = {
6017
5476
  body?: never;
6018
- headers?: {
6019
- /**
6020
- * Authorization
6021
- */
6022
- authorization?: string | null;
6023
- };
6024
5477
  path: {
6025
5478
  /**
6026
5479
  * Graph Id
6027
- * Graph database identifier
6028
5480
  */
6029
5481
  graph_id: string;
6030
5482
  };
@@ -6039,11 +5491,6 @@ export type ListBackupsData = {
6039
5491
  * Number of backups to skip
6040
5492
  */
6041
5493
  offset?: number;
6042
- /**
6043
- * Token
6044
- * JWT token for SSE authentication
6045
- */
6046
- token?: string | null;
6047
5494
  };
6048
5495
  url: '/v1/graphs/{graph_id}/backups';
6049
5496
  };
@@ -6068,26 +5515,13 @@ export type ListBackupsResponse = ListBackupsResponses[keyof ListBackupsResponse
6068
5515
 
6069
5516
  export type CreateBackupData = {
6070
5517
  body: BackupCreateRequest;
6071
- headers?: {
6072
- /**
6073
- * Authorization
6074
- */
6075
- authorization?: string | null;
6076
- };
6077
5518
  path: {
6078
5519
  /**
6079
5520
  * Graph Id
6080
- * Graph database identifier
6081
5521
  */
6082
5522
  graph_id: string;
6083
5523
  };
6084
- query?: {
6085
- /**
6086
- * Token
6087
- * JWT token for SSE authentication
6088
- */
6089
- token?: string | null;
6090
- };
5524
+ query?: never;
6091
5525
  url: '/v1/graphs/{graph_id}/backups';
6092
5526
  };
6093
5527
 
@@ -6125,12 +5559,6 @@ export type CreateBackupResponses = {
6125
5559
 
6126
5560
  export type GetBackupDownloadUrlData = {
6127
5561
  body?: never;
6128
- headers?: {
6129
- /**
6130
- * Authorization
6131
- */
6132
- authorization?: string | null;
6133
- };
6134
5562
  path: {
6135
5563
  /**
6136
5564
  * Backup Id
@@ -6139,7 +5567,6 @@ export type GetBackupDownloadUrlData = {
6139
5567
  backup_id: string;
6140
5568
  /**
6141
5569
  * Graph Id
6142
- * Graph database identifier
6143
5570
  */
6144
5571
  graph_id: string;
6145
5572
  };
@@ -6149,11 +5576,6 @@ export type GetBackupDownloadUrlData = {
6149
5576
  * URL expiration time in seconds
6150
5577
  */
6151
5578
  expires_in?: number;
6152
- /**
6153
- * Token
6154
- * JWT token for SSE authentication
6155
- */
6156
- token?: string | null;
6157
5579
  };
6158
5580
  url: '/v1/graphs/{graph_id}/backups/{backup_id}/download';
6159
5581
  };
@@ -6193,12 +5615,6 @@ export type GetBackupDownloadUrlResponse = GetBackupDownloadUrlResponses[keyof G
6193
5615
 
6194
5616
  export type RestoreBackupData = {
6195
5617
  body: BackupRestoreRequest;
6196
- headers?: {
6197
- /**
6198
- * Authorization
6199
- */
6200
- authorization?: string | null;
6201
- };
6202
5618
  path: {
6203
5619
  /**
6204
5620
  * Backup Id
@@ -6207,17 +5623,10 @@ export type RestoreBackupData = {
6207
5623
  backup_id: string;
6208
5624
  /**
6209
5625
  * Graph Id
6210
- * Graph database identifier
6211
5626
  */
6212
5627
  graph_id: string;
6213
5628
  };
6214
- query?: {
6215
- /**
6216
- * Token
6217
- * JWT token for SSE authentication
6218
- */
6219
- token?: string | null;
6220
- };
5629
+ query?: never;
6221
5630
  url: '/v1/graphs/{graph_id}/backups/{backup_id}/restore';
6222
5631
  };
6223
5632
 
@@ -6255,26 +5664,13 @@ export type RestoreBackupResponses = {
6255
5664
 
6256
5665
  export type GetBackupStatsData = {
6257
5666
  body?: never;
6258
- headers?: {
6259
- /**
6260
- * Authorization
6261
- */
6262
- authorization?: string | null;
6263
- };
6264
5667
  path: {
6265
5668
  /**
6266
5669
  * Graph Id
6267
- * Graph database identifier
6268
5670
  */
6269
5671
  graph_id: string;
6270
5672
  };
6271
- query?: {
6272
- /**
6273
- * Token
6274
- * JWT token for SSE authentication
6275
- */
6276
- token?: string | null;
6277
- };
5673
+ query?: never;
6278
5674
  url: '/v1/graphs/{graph_id}/backups/stats';
6279
5675
  };
6280
5676
 
@@ -6298,26 +5694,13 @@ export type GetBackupStatsResponse = GetBackupStatsResponses[keyof GetBackupStat
6298
5694
 
6299
5695
  export type GetGraphMetricsData = {
6300
5696
  body?: never;
6301
- headers?: {
6302
- /**
6303
- * Authorization
6304
- */
6305
- authorization?: string | null;
6306
- };
6307
5697
  path: {
6308
5698
  /**
6309
5699
  * Graph Id
6310
- * The graph ID to get metrics for
6311
5700
  */
6312
5701
  graph_id: string;
6313
5702
  };
6314
- query?: {
6315
- /**
6316
- * Token
6317
- * JWT token for SSE authentication
6318
- */
6319
- token?: string | null;
6320
- };
5703
+ query?: never;
6321
5704
  url: '/v1/graphs/{graph_id}/analytics';
6322
5705
  };
6323
5706
 
@@ -6353,30 +5736,18 @@ export type GetGraphMetricsResponse = GetGraphMetricsResponses[keyof GetGraphMet
6353
5736
 
6354
5737
  export type GetGraphUsageStatsData = {
6355
5738
  body?: never;
6356
- headers?: {
6357
- /**
6358
- * Authorization
6359
- */
6360
- authorization?: string | null;
6361
- };
6362
5739
  path: {
6363
5740
  /**
6364
5741
  * Graph Id
6365
- * The graph ID to get usage stats for
6366
5742
  */
6367
5743
  graph_id: string;
6368
5744
  };
6369
5745
  query?: {
6370
5746
  /**
6371
5747
  * Include Details
6372
- * Include detailed metrics (may be slower)
6373
- */
6374
- include_details?: boolean;
6375
- /**
6376
- * Token
6377
- * JWT token for SSE authentication
5748
+ * Include detailed metrics (may be slower)
6378
5749
  */
6379
- token?: string | null;
5750
+ include_details?: boolean;
6380
5751
  };
6381
5752
  url: '/v1/graphs/{graph_id}/analytics/usage';
6382
5753
  };
@@ -6409,16 +5780,9 @@ export type GetGraphUsageStatsResponse = GetGraphUsageStatsResponses[keyof GetGr
6409
5780
 
6410
5781
  export type ExecuteCypherQueryData = {
6411
5782
  body: CypherQueryRequest;
6412
- headers?: {
6413
- /**
6414
- * Authorization
6415
- */
6416
- authorization?: string | null;
6417
- };
6418
5783
  path: {
6419
5784
  /**
6420
5785
  * Graph Id
6421
- * Graph database identifier
6422
5786
  */
6423
5787
  graph_id: string;
6424
5788
  };
@@ -6432,17 +5796,12 @@ export type ExecuteCypherQueryData = {
6432
5796
  * Chunk Size
6433
5797
  * Rows per chunk for streaming
6434
5798
  */
6435
- chunk_size?: number;
5799
+ chunk_size?: number | null;
6436
5800
  /**
6437
5801
  * Test Mode
6438
5802
  * Enable test mode for better debugging
6439
5803
  */
6440
5804
  test_mode?: boolean;
6441
- /**
6442
- * Token
6443
- * JWT token for SSE authentication
6444
- */
6445
- token?: string | null;
6446
5805
  };
6447
5806
  url: '/v1/graphs/{graph_id}/query';
6448
5807
  };
@@ -6493,26 +5852,13 @@ export type ExecuteCypherQueryResponses = {
6493
5852
 
6494
5853
  export type GetGraphSchemaData = {
6495
5854
  body?: never;
6496
- headers?: {
6497
- /**
6498
- * Authorization
6499
- */
6500
- authorization?: string | null;
6501
- };
6502
5855
  path: {
6503
5856
  /**
6504
5857
  * Graph Id
6505
- * The graph database to get schema for
6506
5858
  */
6507
5859
  graph_id: string;
6508
5860
  };
6509
- query?: {
6510
- /**
6511
- * Token
6512
- * JWT token for SSE authentication
6513
- */
6514
- token?: string | null;
6515
- };
5861
+ query?: never;
6516
5862
  url: '/v1/graphs/{graph_id}/schema';
6517
5863
  };
6518
5864
 
@@ -6529,34 +5875,28 @@ export type GetGraphSchemaErrors = {
6529
5875
  * Failed to retrieve schema
6530
5876
  */
6531
5877
  500: unknown;
5878
+ /**
5879
+ * Schema operation timed out
5880
+ */
5881
+ 504: unknown;
6532
5882
  };
6533
5883
 
6534
5884
  export type GetGraphSchemaError = GetGraphSchemaErrors[keyof GetGraphSchemaErrors];
6535
5885
 
6536
5886
  export type GetGraphSchemaResponses = {
6537
5887
  /**
6538
- * Response Getgraphschema
6539
5888
  * Schema information retrieved successfully
6540
5889
  */
6541
- 200: {
6542
- [key: string]: unknown;
6543
- };
5890
+ 200: SchemaInfoResponse;
6544
5891
  };
6545
5892
 
6546
5893
  export type GetGraphSchemaResponse = GetGraphSchemaResponses[keyof GetGraphSchemaResponses];
6547
5894
 
6548
5895
  export type ExportGraphSchemaData = {
6549
5896
  body?: never;
6550
- headers?: {
6551
- /**
6552
- * Authorization
6553
- */
6554
- authorization?: string | null;
6555
- };
6556
5897
  path: {
6557
5898
  /**
6558
5899
  * Graph Id
6559
- * The graph ID to export schema from
6560
5900
  */
6561
5901
  graph_id: string;
6562
5902
  };
@@ -6568,30 +5908,37 @@ export type ExportGraphSchemaData = {
6568
5908
  format?: string;
6569
5909
  /**
6570
5910
  * Include Data Stats
6571
- * Include statistics about actual data in the graph
5911
+ * Include statistics about actual data in the graph (node counts, relationship counts)
6572
5912
  */
6573
5913
  include_data_stats?: boolean;
6574
- /**
6575
- * Token
6576
- * JWT token for SSE authentication
6577
- */
6578
- token?: string | null;
6579
5914
  };
6580
5915
  url: '/v1/graphs/{graph_id}/schema/export';
6581
5916
  };
6582
5917
 
6583
5918
  export type ExportGraphSchemaErrors = {
5919
+ /**
5920
+ * Access denied to graph
5921
+ */
5922
+ 403: unknown;
5923
+ /**
5924
+ * Schema not found for graph
5925
+ */
5926
+ 404: unknown;
6584
5927
  /**
6585
5928
  * Validation Error
6586
5929
  */
6587
5930
  422: HttpValidationError;
5931
+ /**
5932
+ * Failed to export schema
5933
+ */
5934
+ 500: unknown;
6588
5935
  };
6589
5936
 
6590
5937
  export type ExportGraphSchemaError = ExportGraphSchemaErrors[keyof ExportGraphSchemaErrors];
6591
5938
 
6592
5939
  export type ExportGraphSchemaResponses = {
6593
5940
  /**
6594
- * Successful Response
5941
+ * Schema exported successfully
6595
5942
  */
6596
5943
  200: SchemaExportResponse;
6597
5944
  };
@@ -6603,26 +5950,13 @@ export type ValidateSchemaData = {
6603
5950
  * Schema definition to validate
6604
5951
  */
6605
5952
  body: SchemaValidationRequest;
6606
- headers?: {
6607
- /**
6608
- * Authorization
6609
- */
6610
- authorization?: string | null;
6611
- };
6612
5953
  path: {
6613
5954
  /**
6614
5955
  * Graph Id
6615
- * Graph database identifier
6616
5956
  */
6617
5957
  graph_id: string;
6618
5958
  };
6619
- query?: {
6620
- /**
6621
- * Token
6622
- * JWT token for SSE authentication
6623
- */
6624
- token?: string | null;
6625
- };
5959
+ query?: never;
6626
5960
  url: '/v1/graphs/{graph_id}/schema/validate';
6627
5961
  };
6628
5962
 
@@ -6658,26 +5992,13 @@ export type ValidateSchemaResponse = ValidateSchemaResponses[keyof ValidateSchem
6658
5992
 
6659
5993
  export type GetCurrentGraphBillData = {
6660
5994
  body?: never;
6661
- headers?: {
6662
- /**
6663
- * Authorization
6664
- */
6665
- authorization?: string | null;
6666
- };
6667
5995
  path: {
6668
5996
  /**
6669
5997
  * Graph Id
6670
- * Graph database identifier
6671
5998
  */
6672
5999
  graph_id: string;
6673
6000
  };
6674
- query?: {
6675
- /**
6676
- * Token
6677
- * JWT token for SSE authentication
6678
- */
6679
- token?: string | null;
6680
- };
6001
+ query?: never;
6681
6002
  url: '/v1/graphs/{graph_id}/billing/current';
6682
6003
  };
6683
6004
 
@@ -6716,16 +6037,9 @@ export type GetCurrentGraphBillResponse = GetCurrentGraphBillResponses[keyof Get
6716
6037
 
6717
6038
  export type GetGraphUsageDetailsData = {
6718
6039
  body?: never;
6719
- headers?: {
6720
- /**
6721
- * Authorization
6722
- */
6723
- authorization?: string | null;
6724
- };
6725
6040
  path: {
6726
6041
  /**
6727
6042
  * Graph Id
6728
- * Graph database identifier
6729
6043
  */
6730
6044
  graph_id: string;
6731
6045
  };
@@ -6740,11 +6054,6 @@ export type GetGraphUsageDetailsData = {
6740
6054
  * Month (defaults to current)
6741
6055
  */
6742
6056
  month?: number | null;
6743
- /**
6744
- * Token
6745
- * JWT token for SSE authentication
6746
- */
6747
- token?: string | null;
6748
6057
  };
6749
6058
  url: '/v1/graphs/{graph_id}/billing/usage';
6750
6059
  };
@@ -6788,16 +6097,9 @@ export type GetGraphUsageDetailsResponse = GetGraphUsageDetailsResponses[keyof G
6788
6097
 
6789
6098
  export type GetGraphBillingHistoryData = {
6790
6099
  body?: never;
6791
- headers?: {
6792
- /**
6793
- * Authorization
6794
- */
6795
- authorization?: string | null;
6796
- };
6797
6100
  path: {
6798
6101
  /**
6799
6102
  * Graph Id
6800
- * Graph database identifier
6801
6103
  */
6802
6104
  graph_id: string;
6803
6105
  };
@@ -6807,11 +6109,6 @@ export type GetGraphBillingHistoryData = {
6807
6109
  * Number of months to retrieve (1-24)
6808
6110
  */
6809
6111
  months?: number;
6810
- /**
6811
- * Token
6812
- * JWT token for SSE authentication
6813
- */
6814
- token?: string | null;
6815
6112
  };
6816
6113
  url: '/v1/graphs/{graph_id}/billing/history';
6817
6114
  };
@@ -6851,12 +6148,6 @@ export type GetGraphBillingHistoryResponse = GetGraphBillingHistoryResponses[key
6851
6148
 
6852
6149
  export type GetGraphMonthlyBillData = {
6853
6150
  body?: never;
6854
- headers?: {
6855
- /**
6856
- * Authorization
6857
- */
6858
- authorization?: string | null;
6859
- };
6860
6151
  path: {
6861
6152
  /**
6862
6153
  * Year
@@ -6870,17 +6161,10 @@ export type GetGraphMonthlyBillData = {
6870
6161
  month: number;
6871
6162
  /**
6872
6163
  * Graph Id
6873
- * Graph database identifier
6874
6164
  */
6875
6165
  graph_id: string;
6876
6166
  };
6877
- query?: {
6878
- /**
6879
- * Token
6880
- * JWT token for SSE authentication
6881
- */
6882
- token?: string | null;
6883
- };
6167
+ query?: never;
6884
6168
  url: '/v1/graphs/{graph_id}/billing/history/{year}/{month}';
6885
6169
  };
6886
6170
 
@@ -6923,12 +6207,6 @@ export type GetGraphMonthlyBillResponse = GetGraphMonthlyBillResponses[keyof Get
6923
6207
 
6924
6208
  export type GetCreditSummaryData = {
6925
6209
  body?: never;
6926
- headers?: {
6927
- /**
6928
- * Authorization
6929
- */
6930
- authorization?: string | null;
6931
- };
6932
6210
  path: {
6933
6211
  /**
6934
6212
  * Graph Id
@@ -6936,13 +6214,7 @@ export type GetCreditSummaryData = {
6936
6214
  */
6937
6215
  graph_id: string;
6938
6216
  };
6939
- query?: {
6940
- /**
6941
- * Token
6942
- * JWT token for SSE authentication
6943
- */
6944
- token?: string | null;
6945
- };
6217
+ query?: never;
6946
6218
  url: '/v1/graphs/{graph_id}/credits/summary';
6947
6219
  };
6948
6220
 
@@ -6978,16 +6250,9 @@ export type GetCreditSummaryResponse = GetCreditSummaryResponses[keyof GetCredit
6978
6250
 
6979
6251
  export type ListCreditTransactionsData = {
6980
6252
  body?: never;
6981
- headers?: {
6982
- /**
6983
- * Authorization
6984
- */
6985
- authorization?: string | null;
6986
- };
6987
6253
  path: {
6988
6254
  /**
6989
6255
  * Graph Id
6990
- * Graph database identifier
6991
6256
  */
6992
6257
  graph_id: string;
6993
6258
  };
@@ -7022,11 +6287,6 @@ export type ListCreditTransactionsData = {
7022
6287
  * Number of transactions to skip
7023
6288
  */
7024
6289
  offset?: number;
7025
- /**
7026
- * Token
7027
- * JWT token for SSE authentication
7028
- */
7029
- token?: string | null;
7030
6290
  };
7031
6291
  url: '/v1/graphs/{graph_id}/credits/transactions';
7032
6292
  };
@@ -7063,12 +6323,6 @@ export type ListCreditTransactionsResponse = ListCreditTransactionsResponses[key
7063
6323
 
7064
6324
  export type CheckCreditBalanceData = {
7065
6325
  body?: never;
7066
- headers?: {
7067
- /**
7068
- * Authorization
7069
- */
7070
- authorization?: string | null;
7071
- };
7072
6326
  path: {
7073
6327
  /**
7074
6328
  * Graph Id
@@ -7087,11 +6341,6 @@ export type CheckCreditBalanceData = {
7087
6341
  * Custom base cost (uses default if not provided)
7088
6342
  */
7089
6343
  base_cost?: number | string | null;
7090
- /**
7091
- * Token
7092
- * JWT token for SSE authentication
7093
- */
7094
- token?: string | null;
7095
6344
  };
7096
6345
  url: '/v1/graphs/{graph_id}/credits/balance/check';
7097
6346
  };
@@ -7131,12 +6380,6 @@ export type CheckCreditBalanceResponse = CheckCreditBalanceResponses[keyof Check
7131
6380
 
7132
6381
  export type GetStorageUsageData = {
7133
6382
  body?: never;
7134
- headers?: {
7135
- /**
7136
- * Authorization
7137
- */
7138
- authorization?: string | null;
7139
- };
7140
6383
  path: {
7141
6384
  /**
7142
6385
  * Graph Id
@@ -7150,11 +6393,6 @@ export type GetStorageUsageData = {
7150
6393
  * Number of days of history to return
7151
6394
  */
7152
6395
  days?: number;
7153
- /**
7154
- * Token
7155
- * JWT token for SSE authentication
7156
- */
7157
- token?: string | null;
7158
6396
  };
7159
6397
  url: '/v1/graphs/{graph_id}/credits/storage/usage';
7160
6398
  };
@@ -7190,12 +6428,6 @@ export type GetStorageUsageResponse = GetStorageUsageResponses[keyof GetStorageU
7190
6428
 
7191
6429
  export type CheckStorageLimitsData = {
7192
6430
  body?: never;
7193
- headers?: {
7194
- /**
7195
- * Authorization
7196
- */
7197
- authorization?: string | null;
7198
- };
7199
6431
  path: {
7200
6432
  /**
7201
6433
  * Graph Id
@@ -7203,13 +6435,7 @@ export type CheckStorageLimitsData = {
7203
6435
  */
7204
6436
  graph_id: string;
7205
6437
  };
7206
- query?: {
7207
- /**
7208
- * Token
7209
- * JWT token for SSE authentication
7210
- */
7211
- token?: string | null;
7212
- };
6438
+ query?: never;
7213
6439
  url: '/v1/graphs/{graph_id}/credits/storage/limits';
7214
6440
  };
7215
6441
 
@@ -7245,26 +6471,13 @@ export type CheckStorageLimitsResponse = CheckStorageLimitsResponses[keyof Check
7245
6471
 
7246
6472
  export type GetDatabaseHealthData = {
7247
6473
  body?: never;
7248
- headers?: {
7249
- /**
7250
- * Authorization
7251
- */
7252
- authorization?: string | null;
7253
- };
7254
6474
  path: {
7255
6475
  /**
7256
6476
  * Graph Id
7257
- * Graph database identifier
7258
6477
  */
7259
6478
  graph_id: string;
7260
6479
  };
7261
- query?: {
7262
- /**
7263
- * Token
7264
- * JWT token for SSE authentication
7265
- */
7266
- token?: string | null;
7267
- };
6480
+ query?: never;
7268
6481
  url: '/v1/graphs/{graph_id}/health';
7269
6482
  };
7270
6483
 
@@ -7300,26 +6513,13 @@ export type GetDatabaseHealthResponse = GetDatabaseHealthResponses[keyof GetData
7300
6513
 
7301
6514
  export type GetDatabaseInfoData = {
7302
6515
  body?: never;
7303
- headers?: {
7304
- /**
7305
- * Authorization
7306
- */
7307
- authorization?: string | null;
7308
- };
7309
6516
  path: {
7310
6517
  /**
7311
6518
  * Graph Id
7312
- * Graph database identifier
7313
6519
  */
7314
6520
  graph_id: string;
7315
6521
  };
7316
- query?: {
7317
- /**
7318
- * Token
7319
- * JWT token for SSE authentication
7320
- */
7321
- token?: string | null;
7322
- };
6522
+ query?: never;
7323
6523
  url: '/v1/graphs/{graph_id}/info';
7324
6524
  };
7325
6525
 
@@ -7355,26 +6555,13 @@ export type GetDatabaseInfoResponse = GetDatabaseInfoResponses[keyof GetDatabase
7355
6555
 
7356
6556
  export type GetGraphLimitsData = {
7357
6557
  body?: never;
7358
- headers?: {
7359
- /**
7360
- * Authorization
7361
- */
7362
- authorization?: string | null;
7363
- };
7364
6558
  path: {
7365
6559
  /**
7366
6560
  * Graph Id
7367
- * Graph database identifier (user graph or shared repository)
7368
6561
  */
7369
6562
  graph_id: string;
7370
6563
  };
7371
- query?: {
7372
- /**
7373
- * Token
7374
- * JWT token for SSE authentication
7375
- */
7376
- token?: string | null;
7377
- };
6564
+ query?: never;
7378
6565
  url: '/v1/graphs/{graph_id}/limits';
7379
6566
  };
7380
6567
 
@@ -7413,26 +6600,13 @@ export type GetGraphLimitsResponse = GetGraphLimitsResponses[keyof GetGraphLimit
7413
6600
 
7414
6601
  export type ListSubgraphsData = {
7415
6602
  body?: never;
7416
- headers?: {
7417
- /**
7418
- * Authorization
7419
- */
7420
- authorization?: string | null;
7421
- };
7422
6603
  path: {
7423
6604
  /**
7424
6605
  * Graph Id
7425
- * Parent graph ID (e.g., 'kg1a2b3c4d5')
7426
6606
  */
7427
6607
  graph_id: string;
7428
6608
  };
7429
- query?: {
7430
- /**
7431
- * Token
7432
- * JWT token for SSE authentication
7433
- */
7434
- token?: string | null;
7435
- };
6609
+ query?: never;
7436
6610
  url: '/v1/graphs/{graph_id}/subgraphs';
7437
6611
  };
7438
6612
 
@@ -7451,31 +6625,18 @@ export type ListSubgraphsResponses = {
7451
6625
  */
7452
6626
  200: ListSubgraphsResponse;
7453
6627
  };
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
- };
6628
+
6629
+ export type ListSubgraphsResponse2 = ListSubgraphsResponses[keyof ListSubgraphsResponses];
6630
+
6631
+ export type CreateSubgraphData = {
6632
+ body: CreateSubgraphRequest;
7465
6633
  path: {
7466
6634
  /**
7467
6635
  * Graph Id
7468
- * Parent graph ID (e.g., 'kg1a2b3c4d5')
7469
6636
  */
7470
6637
  graph_id: string;
7471
6638
  };
7472
- query?: {
7473
- /**
7474
- * Token
7475
- * JWT token for SSE authentication
7476
- */
7477
- token?: string | null;
7478
- };
6639
+ query?: never;
7479
6640
  url: '/v1/graphs/{graph_id}/subgraphs';
7480
6641
  };
7481
6642
 
@@ -7499,16 +6660,9 @@ export type CreateSubgraphResponse = CreateSubgraphResponses[keyof CreateSubgrap
7499
6660
 
7500
6661
  export type DeleteSubgraphData = {
7501
6662
  body: DeleteSubgraphRequest;
7502
- headers?: {
7503
- /**
7504
- * Authorization
7505
- */
7506
- authorization?: string | null;
7507
- };
7508
6663
  path: {
7509
6664
  /**
7510
6665
  * Graph Id
7511
- * Parent graph identifier
7512
6666
  */
7513
6667
  graph_id: string;
7514
6668
  /**
@@ -7517,13 +6671,7 @@ export type DeleteSubgraphData = {
7517
6671
  */
7518
6672
  subgraph_id: string;
7519
6673
  };
7520
- query?: {
7521
- /**
7522
- * Token
7523
- * JWT token for SSE authentication
7524
- */
7525
- token?: string | null;
7526
- };
6674
+ query?: never;
7527
6675
  url: '/v1/graphs/{graph_id}/subgraphs/{subgraph_id}';
7528
6676
  };
7529
6677
 
@@ -7571,16 +6719,9 @@ export type DeleteSubgraphResponse2 = DeleteSubgraphResponses[keyof DeleteSubgra
7571
6719
 
7572
6720
  export type GetSubgraphInfoData = {
7573
6721
  body?: never;
7574
- headers?: {
7575
- /**
7576
- * Authorization
7577
- */
7578
- authorization?: string | null;
7579
- };
7580
6722
  path: {
7581
6723
  /**
7582
6724
  * Graph Id
7583
- * Parent graph identifier
7584
6725
  */
7585
6726
  graph_id: string;
7586
6727
  /**
@@ -7589,13 +6730,7 @@ export type GetSubgraphInfoData = {
7589
6730
  */
7590
6731
  subgraph_id: string;
7591
6732
  };
7592
- query?: {
7593
- /**
7594
- * Token
7595
- * JWT token for SSE authentication
7596
- */
7597
- token?: string | null;
7598
- };
6733
+ query?: never;
7599
6734
  url: '/v1/graphs/{graph_id}/subgraphs/{subgraph_id}/info';
7600
6735
  };
7601
6736
 
@@ -7639,26 +6774,13 @@ export type GetSubgraphInfoResponse = GetSubgraphInfoResponses[keyof GetSubgraph
7639
6774
 
7640
6775
  export type GetSubgraphQuotaData = {
7641
6776
  body?: never;
7642
- headers?: {
7643
- /**
7644
- * Authorization
7645
- */
7646
- authorization?: string | null;
7647
- };
7648
6777
  path: {
7649
6778
  /**
7650
6779
  * Graph Id
7651
- * Parent graph identifier
7652
6780
  */
7653
6781
  graph_id: string;
7654
6782
  };
7655
- query?: {
7656
- /**
7657
- * Token
7658
- * JWT token for SSE authentication
7659
- */
7660
- token?: string | null;
7661
- };
6783
+ query?: never;
7662
6784
  url: '/v1/graphs/{graph_id}/subgraphs/quota';
7663
6785
  };
7664
6786
 
@@ -7698,26 +6820,13 @@ export type GetSubgraphQuotaResponse = GetSubgraphQuotaResponses[keyof GetSubgra
7698
6820
 
7699
6821
  export type ListTablesData = {
7700
6822
  body?: never;
7701
- headers?: {
7702
- /**
7703
- * Authorization
7704
- */
7705
- authorization?: string | null;
7706
- };
7707
6823
  path: {
7708
6824
  /**
7709
6825
  * Graph Id
7710
- * Graph database identifier
7711
6826
  */
7712
6827
  graph_id: string;
7713
6828
  };
7714
- query?: {
7715
- /**
7716
- * Token
7717
- * JWT token for SSE authentication
7718
- */
7719
- token?: string | null;
7720
- };
6829
+ query?: never;
7721
6830
  url: '/v1/graphs/{graph_id}/tables';
7722
6831
  };
7723
6832
 
@@ -7757,16 +6866,9 @@ export type ListTablesResponse = ListTablesResponses[keyof ListTablesResponses];
7757
6866
 
7758
6867
  export type ListTableFilesData = {
7759
6868
  body?: never;
7760
- headers?: {
7761
- /**
7762
- * Authorization
7763
- */
7764
- authorization?: string | null;
7765
- };
7766
6869
  path: {
7767
6870
  /**
7768
6871
  * Graph Id
7769
- * Graph database identifier
7770
6872
  */
7771
6873
  graph_id: string;
7772
6874
  /**
@@ -7775,13 +6877,7 @@ export type ListTableFilesData = {
7775
6877
  */
7776
6878
  table_name: string;
7777
6879
  };
7778
- query?: {
7779
- /**
7780
- * Token
7781
- * JWT token for SSE authentication
7782
- */
7783
- token?: string | null;
7784
- };
6880
+ query?: never;
7785
6881
  url: '/v1/graphs/{graph_id}/tables/{table_name}/files';
7786
6882
  };
7787
6883
 
@@ -7824,16 +6920,9 @@ export type GetUploadUrlData = {
7824
6920
  * Upload request
7825
6921
  */
7826
6922
  body: FileUploadRequest;
7827
- headers?: {
7828
- /**
7829
- * Authorization
7830
- */
7831
- authorization?: string | null;
7832
- };
7833
6923
  path: {
7834
6924
  /**
7835
6925
  * Graph Id
7836
- * Graph database identifier
7837
6926
  */
7838
6927
  graph_id: string;
7839
6928
  /**
@@ -7842,13 +6931,7 @@ export type GetUploadUrlData = {
7842
6931
  */
7843
6932
  table_name: string;
7844
6933
  };
7845
- query?: {
7846
- /**
7847
- * Token
7848
- * JWT token for SSE authentication
7849
- */
7850
- token?: string | null;
7851
- };
6934
+ query?: never;
7852
6935
  url: '/v1/graphs/{graph_id}/tables/{table_name}/files';
7853
6936
  };
7854
6937
 
@@ -7892,16 +6975,9 @@ export type GetUploadUrlResponse = GetUploadUrlResponses[keyof GetUploadUrlRespo
7892
6975
 
7893
6976
  export type DeleteFileData = {
7894
6977
  body?: never;
7895
- headers?: {
7896
- /**
7897
- * Authorization
7898
- */
7899
- authorization?: string | null;
7900
- };
7901
6978
  path: {
7902
6979
  /**
7903
6980
  * Graph Id
7904
- * Graph database identifier
7905
6981
  */
7906
6982
  graph_id: string;
7907
6983
  /**
@@ -7910,13 +6986,7 @@ export type DeleteFileData = {
7910
6986
  */
7911
6987
  file_id: string;
7912
6988
  };
7913
- query?: {
7914
- /**
7915
- * Token
7916
- * JWT token for SSE authentication
7917
- */
7918
- token?: string | null;
7919
- };
6989
+ query?: never;
7920
6990
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
7921
6991
  };
7922
6992
 
@@ -7956,16 +7026,9 @@ export type DeleteFileResponse2 = DeleteFileResponses[keyof DeleteFileResponses]
7956
7026
 
7957
7027
  export type GetFileInfoData = {
7958
7028
  body?: never;
7959
- headers?: {
7960
- /**
7961
- * Authorization
7962
- */
7963
- authorization?: string | null;
7964
- };
7965
7029
  path: {
7966
7030
  /**
7967
7031
  * Graph Id
7968
- * Graph database identifier
7969
7032
  */
7970
7033
  graph_id: string;
7971
7034
  /**
@@ -7974,13 +7037,7 @@ export type GetFileInfoData = {
7974
7037
  */
7975
7038
  file_id: string;
7976
7039
  };
7977
- query?: {
7978
- /**
7979
- * Token
7980
- * JWT token for SSE authentication
7981
- */
7982
- token?: string | null;
7983
- };
7040
+ query?: never;
7984
7041
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
7985
7042
  };
7986
7043
 
@@ -8019,16 +7076,9 @@ export type UpdateFileStatusData = {
8019
7076
  * Status update
8020
7077
  */
8021
7078
  body: FileStatusUpdate;
8022
- headers?: {
8023
- /**
8024
- * Authorization
8025
- */
8026
- authorization?: string | null;
8027
- };
8028
7079
  path: {
8029
7080
  /**
8030
7081
  * Graph Id
8031
- * Graph database identifier
8032
7082
  */
8033
7083
  graph_id: string;
8034
7084
  /**
@@ -8037,13 +7087,7 @@ export type UpdateFileStatusData = {
8037
7087
  */
8038
7088
  file_id: string;
8039
7089
  };
8040
- query?: {
8041
- /**
8042
- * Token
8043
- * JWT token for SSE authentication
8044
- */
8045
- token?: string | null;
8046
- };
7090
+ query?: never;
8047
7091
  url: '/v1/graphs/{graph_id}/tables/files/{file_id}';
8048
7092
  };
8049
7093
 
@@ -8097,26 +7141,13 @@ export type IngestTablesData = {
8097
7141
  * Ingestion request
8098
7142
  */
8099
7143
  body: BulkIngestRequest;
8100
- headers?: {
8101
- /**
8102
- * Authorization
8103
- */
8104
- authorization?: string | null;
8105
- };
8106
7144
  path: {
8107
7145
  /**
8108
7146
  * Graph Id
8109
- * Graph database identifier
8110
7147
  */
8111
7148
  graph_id: string;
8112
7149
  };
8113
- query?: {
8114
- /**
8115
- * Token
8116
- * JWT token for SSE authentication
8117
- */
8118
- token?: string | null;
8119
- };
7150
+ query?: never;
8120
7151
  url: '/v1/graphs/{graph_id}/tables/ingest';
8121
7152
  };
8122
7153
 
@@ -8163,26 +7194,13 @@ export type QueryTablesData = {
8163
7194
  * SQL query request
8164
7195
  */
8165
7196
  body: TableQueryRequest;
8166
- headers?: {
8167
- /**
8168
- * Authorization
8169
- */
8170
- authorization?: string | null;
8171
- };
8172
7197
  path: {
8173
7198
  /**
8174
7199
  * Graph Id
8175
- * Graph database identifier
8176
7200
  */
8177
7201
  graph_id: string;
8178
7202
  };
8179
- query?: {
8180
- /**
8181
- * Token
8182
- * JWT token for SSE authentication
8183
- */
8184
- token?: string | null;
8185
- };
7203
+ query?: never;
8186
7204
  url: '/v1/graphs/{graph_id}/tables/query';
8187
7205
  };
8188
7206
 
@@ -8230,35 +7248,21 @@ export type QueryTablesResponse = QueryTablesResponses[keyof QueryTablesResponse
8230
7248
 
8231
7249
  export type GetGraphsData = {
8232
7250
  body?: never;
8233
- headers?: {
8234
- /**
8235
- * Authorization
8236
- */
8237
- authorization?: string | null;
8238
- };
8239
7251
  path?: never;
8240
- query?: {
8241
- /**
8242
- * Token
8243
- * JWT token for SSE authentication
8244
- */
8245
- token?: string | null;
8246
- };
7252
+ query?: never;
8247
7253
  url: '/v1/graphs';
8248
7254
  };
8249
7255
 
8250
7256
  export type GetGraphsErrors = {
8251
7257
  /**
8252
- * Validation Error
7258
+ * Error retrieving graphs
8253
7259
  */
8254
- 422: HttpValidationError;
7260
+ 500: unknown;
8255
7261
  };
8256
7262
 
8257
- export type GetGraphsError = GetGraphsErrors[keyof GetGraphsErrors];
8258
-
8259
7263
  export type GetGraphsResponses = {
8260
7264
  /**
8261
- * Successful Response
7265
+ * Graphs retrieved successfully
8262
7266
  */
8263
7267
  200: UserGraphsResponse;
8264
7268
  };
@@ -8267,20 +7271,8 @@ export type GetGraphsResponse = GetGraphsResponses[keyof GetGraphsResponses];
8267
7271
 
8268
7272
  export type CreateGraphData = {
8269
7273
  body: CreateGraphRequest;
8270
- headers?: {
8271
- /**
8272
- * Authorization
8273
- */
8274
- authorization?: string | null;
8275
- };
8276
7274
  path?: never;
8277
- query?: {
8278
- /**
8279
- * Token
8280
- * JWT token for SSE authentication
8281
- */
8282
- token?: string | null;
8283
- };
7275
+ query?: never;
8284
7276
  url: '/v1/graphs';
8285
7277
  };
8286
7278
 
@@ -8307,9 +7299,16 @@ export type GetAvailableExtensionsData = {
8307
7299
  url: '/v1/graphs/extensions';
8308
7300
  };
8309
7301
 
7302
+ export type GetAvailableExtensionsErrors = {
7303
+ /**
7304
+ * Failed to retrieve extensions
7305
+ */
7306
+ 500: unknown;
7307
+ };
7308
+
8310
7309
  export type GetAvailableExtensionsResponses = {
8311
7310
  /**
8312
- * Successful Response
7311
+ * Extensions retrieved successfully
8313
7312
  */
8314
7313
  200: AvailableExtensionsResponse;
8315
7314
  };
@@ -8318,25 +7317,13 @@ export type GetAvailableExtensionsResponse = GetAvailableExtensionsResponses[key
8318
7317
 
8319
7318
  export type SelectGraphData = {
8320
7319
  body?: never;
8321
- headers?: {
8322
- /**
8323
- * Authorization
8324
- */
8325
- authorization?: string | null;
8326
- };
8327
7320
  path: {
8328
7321
  /**
8329
7322
  * Graph Id
8330
7323
  */
8331
7324
  graph_id: string;
8332
7325
  };
8333
- query?: {
8334
- /**
8335
- * Token
8336
- * JWT token for SSE authentication
8337
- */
8338
- token?: string | null;
8339
- };
7326
+ query?: never;
8340
7327
  url: '/v1/graphs/{graph_id}/select';
8341
7328
  };
8342
7329
 
@@ -8453,12 +7440,6 @@ export type StreamOperationEventsResponses = {
8453
7440
 
8454
7441
  export type GetOperationStatusData = {
8455
7442
  body?: never;
8456
- headers?: {
8457
- /**
8458
- * Authorization
8459
- */
8460
- authorization?: string | null;
8461
- };
8462
7443
  path: {
8463
7444
  /**
8464
7445
  * Operation Id
@@ -8466,13 +7447,7 @@ export type GetOperationStatusData = {
8466
7447
  */
8467
7448
  operation_id: string;
8468
7449
  };
8469
- query?: {
8470
- /**
8471
- * Token
8472
- * JWT token for SSE authentication
8473
- */
8474
- token?: string | null;
8475
- };
7450
+ query?: never;
8476
7451
  url: '/v1/operations/{operation_id}/status';
8477
7452
  };
8478
7453
 
@@ -8511,12 +7486,6 @@ export type GetOperationStatusResponse = GetOperationStatusResponses[keyof GetOp
8511
7486
 
8512
7487
  export type CancelOperationData = {
8513
7488
  body?: never;
8514
- headers?: {
8515
- /**
8516
- * Authorization
8517
- */
8518
- authorization?: string | null;
8519
- };
8520
7489
  path: {
8521
7490
  /**
8522
7491
  * Operation Id
@@ -8524,13 +7493,7 @@ export type CancelOperationData = {
8524
7493
  */
8525
7494
  operation_id: string;
8526
7495
  };
8527
- query?: {
8528
- /**
8529
- * Token
8530
- * JWT token for SSE authentication
8531
- */
8532
- token?: string | null;
8533
- };
7496
+ query?: never;
8534
7497
  url: '/v1/operations/{operation_id}';
8535
7498
  };
8536
7499