@alpic-ai/api 0.0.0-staging.gbd76e40 → 0.0.0-staging.gbde942c

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.mts +1325 -873
  2. package/dist/index.mjs +1575 -33
  3. package/package.json +7 -7
package/dist/index.d.mts CHANGED
@@ -29,6 +29,7 @@ export declare const runtimeSchema: z.ZodEnum<{
29
29
  "python3.14": "python3.14";
30
30
  node22: "node22";
31
31
  node24: "node24";
32
+ node26: "node26";
32
33
  }>;
33
34
  export declare const transportSchema: z.ZodEnum<{
34
35
  stdio: "stdio";
@@ -1383,6 +1384,19 @@ type ClaudeSubmission = z.infer<typeof claudeSubmissionSchemaInternal>;
1383
1384
  type ChatgptSubmission = z.infer<typeof chatgptSubmissionSchemaInternal>;
1384
1385
  type Submission = ClaudeSubmission | ChatgptSubmission;
1385
1386
  //#endregion
1387
+ //#region ../domains/src/telemetry/schemas.d.ts
1388
+ export declare const TELEMETRY_SIGNALS: readonly ["logs", "metrics", "traces"];
1389
+ export declare const telemetrySignalSchema: z.ZodEnum<{
1390
+ logs: "logs";
1391
+ metrics: "metrics";
1392
+ traces: "traces";
1393
+ }>;
1394
+ export declare const OTLP_PROTOCOLS: readonly ["http/protobuf", "http/json"];
1395
+ export declare const otlpProtocolSchema: z.ZodEnum<{
1396
+ "http/protobuf": "http/protobuf";
1397
+ "http/json": "http/json";
1398
+ }>;
1399
+ //#endregion
1386
1400
  //#region src/api.contract.d.ts
1387
1401
  export type ApiContext = {
1388
1402
  request: Request & {
@@ -2346,8 +2360,8 @@ export declare const contract: {
2346
2360
  environmentId: z.ZodString;
2347
2361
  content: z.ZodString;
2348
2362
  source: z.ZodEnum<{
2349
- model: "model";
2350
2363
  user: "user";
2364
+ model: "model";
2351
2365
  }>;
2352
2366
  clientName: z.ZodNullable<z.ZodString>;
2353
2367
  clientId: z.ZodNullable<z.ZodString>;
@@ -2675,6 +2689,206 @@ export declare const contract: {
2675
2689
  }>, Record<never, never>>;
2676
2690
  };
2677
2691
  };
2692
+ telemetryDestinations: {
2693
+ list: {
2694
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
2695
+ environmentId: z.ZodString;
2696
+ }, z.core.$strip>, z.ZodArray<z.ZodObject<{
2697
+ id: z.ZodString;
2698
+ signal: z.ZodEnum<{
2699
+ logs: "logs";
2700
+ metrics: "metrics";
2701
+ traces: "traces";
2702
+ }>;
2703
+ endpoint: z.ZodString;
2704
+ protocol: z.ZodEnum<{
2705
+ "http/protobuf": "http/protobuf";
2706
+ "http/json": "http/json";
2707
+ }>;
2708
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
2709
+ id: z.ZodString;
2710
+ name: z.ZodString;
2711
+ value: z.ZodNull;
2712
+ isSecret: z.ZodLiteral<true>;
2713
+ }, z.core.$strip>, z.ZodObject<{
2714
+ id: z.ZodString;
2715
+ name: z.ZodString;
2716
+ value: z.ZodString;
2717
+ isSecret: z.ZodLiteral<false>;
2718
+ }, z.core.$strip>], "isSecret">>;
2719
+ status: z.ZodEnum<{
2720
+ active: "active";
2721
+ suspended: "suspended";
2722
+ }>;
2723
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
2724
+ credentials: "credentials";
2725
+ "wrong-path": "wrong-path";
2726
+ "wrong-protocol": "wrong-protocol";
2727
+ "invalid-payload": "invalid-payload";
2728
+ "partial-rejection": "partial-rejection";
2729
+ "blocked-target": "blocked-target";
2730
+ timeout: "timeout";
2731
+ unreachable: "unreachable";
2732
+ "receiver-error": "receiver-error";
2733
+ "unexpected-status": "unexpected-status";
2734
+ }>>;
2735
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
2736
+ }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
2737
+ BAD_REQUEST: {};
2738
+ }>, {
2739
+ NOT_FOUND: {};
2740
+ }>, Record<never, never>>;
2741
+ };
2742
+ create: {
2743
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
2744
+ environmentId: z.ZodString;
2745
+ signal: z.ZodEnum<{
2746
+ logs: "logs";
2747
+ metrics: "metrics";
2748
+ traces: "traces";
2749
+ }>;
2750
+ endpoint: z.ZodString;
2751
+ protocol: z.ZodDefault<z.ZodEnum<{
2752
+ "http/protobuf": "http/protobuf";
2753
+ "http/json": "http/json";
2754
+ }>>;
2755
+ isScopedToIntentionalRequestsOnly: z.ZodDefault<z.ZodBoolean>;
2756
+ headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
2757
+ name: z.ZodString;
2758
+ value: z.ZodString;
2759
+ isSecret: z.ZodBoolean;
2760
+ }, z.core.$strip>>>;
2761
+ }, z.core.$strip>, z.ZodObject<{
2762
+ id: z.ZodString;
2763
+ signal: z.ZodEnum<{
2764
+ logs: "logs";
2765
+ metrics: "metrics";
2766
+ traces: "traces";
2767
+ }>;
2768
+ endpoint: z.ZodString;
2769
+ protocol: z.ZodEnum<{
2770
+ "http/protobuf": "http/protobuf";
2771
+ "http/json": "http/json";
2772
+ }>;
2773
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
2774
+ id: z.ZodString;
2775
+ name: z.ZodString;
2776
+ value: z.ZodNull;
2777
+ isSecret: z.ZodLiteral<true>;
2778
+ }, z.core.$strip>, z.ZodObject<{
2779
+ id: z.ZodString;
2780
+ name: z.ZodString;
2781
+ value: z.ZodString;
2782
+ isSecret: z.ZodLiteral<false>;
2783
+ }, z.core.$strip>], "isSecret">>;
2784
+ status: z.ZodEnum<{
2785
+ active: "active";
2786
+ suspended: "suspended";
2787
+ }>;
2788
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
2789
+ credentials: "credentials";
2790
+ "wrong-path": "wrong-path";
2791
+ "wrong-protocol": "wrong-protocol";
2792
+ "invalid-payload": "invalid-payload";
2793
+ "partial-rejection": "partial-rejection";
2794
+ "blocked-target": "blocked-target";
2795
+ timeout: "timeout";
2796
+ unreachable: "unreachable";
2797
+ "receiver-error": "receiver-error";
2798
+ "unexpected-status": "unexpected-status";
2799
+ }>>;
2800
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
2801
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
2802
+ BAD_REQUEST: {};
2803
+ }>, {
2804
+ NOT_FOUND: {};
2805
+ FORBIDDEN: {};
2806
+ OTLP_DESTINATION_UNVERIFIED: {
2807
+ status: number;
2808
+ };
2809
+ INTERNAL_SERVER_ERROR: {};
2810
+ }>, Record<never, never>>;
2811
+ };
2812
+ update: {
2813
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
2814
+ environmentId: z.ZodString;
2815
+ destinationId: z.ZodString;
2816
+ endpoint: z.ZodOptional<z.ZodString>;
2817
+ protocol: z.ZodOptional<z.ZodEnum<{
2818
+ "http/protobuf": "http/protobuf";
2819
+ "http/json": "http/json";
2820
+ }>>;
2821
+ isScopedToIntentionalRequestsOnly: z.ZodOptional<z.ZodBoolean>;
2822
+ headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
2823
+ id: z.ZodOptional<z.ZodString>;
2824
+ name: z.ZodString;
2825
+ value: z.ZodOptional<z.ZodString>;
2826
+ isSecret: z.ZodBoolean;
2827
+ }, z.core.$strip>>>;
2828
+ }, z.core.$strip>, z.ZodObject<{
2829
+ id: z.ZodString;
2830
+ signal: z.ZodEnum<{
2831
+ logs: "logs";
2832
+ metrics: "metrics";
2833
+ traces: "traces";
2834
+ }>;
2835
+ endpoint: z.ZodString;
2836
+ protocol: z.ZodEnum<{
2837
+ "http/protobuf": "http/protobuf";
2838
+ "http/json": "http/json";
2839
+ }>;
2840
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
2841
+ id: z.ZodString;
2842
+ name: z.ZodString;
2843
+ value: z.ZodNull;
2844
+ isSecret: z.ZodLiteral<true>;
2845
+ }, z.core.$strip>, z.ZodObject<{
2846
+ id: z.ZodString;
2847
+ name: z.ZodString;
2848
+ value: z.ZodString;
2849
+ isSecret: z.ZodLiteral<false>;
2850
+ }, z.core.$strip>], "isSecret">>;
2851
+ status: z.ZodEnum<{
2852
+ active: "active";
2853
+ suspended: "suspended";
2854
+ }>;
2855
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
2856
+ credentials: "credentials";
2857
+ "wrong-path": "wrong-path";
2858
+ "wrong-protocol": "wrong-protocol";
2859
+ "invalid-payload": "invalid-payload";
2860
+ "partial-rejection": "partial-rejection";
2861
+ "blocked-target": "blocked-target";
2862
+ timeout: "timeout";
2863
+ unreachable: "unreachable";
2864
+ "receiver-error": "receiver-error";
2865
+ "unexpected-status": "unexpected-status";
2866
+ }>>;
2867
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
2868
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
2869
+ BAD_REQUEST: {};
2870
+ }>, {
2871
+ NOT_FOUND: {};
2872
+ FORBIDDEN: {};
2873
+ OTLP_DESTINATION_UNVERIFIED: {
2874
+ status: number;
2875
+ };
2876
+ }>, Record<never, never>>;
2877
+ };
2878
+ delete: {
2879
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
2880
+ environmentId: z.ZodString;
2881
+ destinationId: z.ZodString;
2882
+ }, z.core.$strip>, z.ZodObject<{
2883
+ success: z.ZodLiteral<true>;
2884
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
2885
+ BAD_REQUEST: {};
2886
+ }>, {
2887
+ NOT_FOUND: {};
2888
+ INTERNAL_SERVER_ERROR: {};
2889
+ }>, Record<never, never>>;
2890
+ };
2891
+ };
2678
2892
  projects: {
2679
2893
  update: {
2680
2894
  v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -2691,6 +2905,7 @@ export declare const contract: {
2691
2905
  "python3.14": "python3.14";
2692
2906
  node22: "node22";
2693
2907
  node24: "node24";
2908
+ node26: "node26";
2694
2909
  }>;
2695
2910
  transport: z.ZodNullable<z.ZodEnum<{
2696
2911
  stdio: "stdio";
@@ -2769,6 +2984,7 @@ export declare const contract: {
2769
2984
  "python3.14": "python3.14";
2770
2985
  node22: "node22";
2771
2986
  node24: "node24";
2987
+ node26: "node26";
2772
2988
  }>;
2773
2989
  transport: z.ZodNullable<z.ZodEnum<{
2774
2990
  stdio: "stdio";
@@ -2846,6 +3062,7 @@ export declare const contract: {
2846
3062
  "python3.14": "python3.14";
2847
3063
  node22: "node22";
2848
3064
  node24: "node24";
3065
+ node26: "node26";
2849
3066
  }>;
2850
3067
  transport: z.ZodNullable<z.ZodEnum<{
2851
3068
  stdio: "stdio";
@@ -2921,6 +3138,7 @@ export declare const contract: {
2921
3138
  "python3.14": "python3.14";
2922
3139
  node22: "node22";
2923
3140
  node24: "node24";
3141
+ node26: "node26";
2924
3142
  }>;
2925
3143
  transport: z.ZodOptional<z.ZodEnum<{
2926
3144
  stdio: "stdio";
@@ -2957,6 +3175,7 @@ export declare const contract: {
2957
3175
  "python3.14": "python3.14";
2958
3176
  node22: "node22";
2959
3177
  node24: "node24";
3178
+ node26: "node26";
2960
3179
  }>;
2961
3180
  transport: z.ZodNullable<z.ZodEnum<{
2962
3181
  stdio: "stdio";
@@ -3271,6 +3490,20 @@ export declare const contract: {
3271
3490
  NOT_FOUND: {};
3272
3491
  }>, Record<never, never>>;
3273
3492
  };
3493
+ list: {
3494
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
3495
+ projectId: z.ZodString;
3496
+ environmentId: z.ZodOptional<z.ZodString>;
3497
+ platform: z.ZodOptional<z.ZodEnum<{
3498
+ chatgpt: "chatgpt";
3499
+ claudeai: "claudeai";
3500
+ }>>;
3501
+ }, z.core.$strip>, z.ZodArray<z.ZodType<Submission, unknown, z.core.$ZodTypeInternals<Submission, unknown>>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
3502
+ BAD_REQUEST: {};
3503
+ }>, {
3504
+ NOT_FOUND: {};
3505
+ }>, Record<never, never>>;
3506
+ };
3274
3507
  get: {
3275
3508
  v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
3276
3509
  submissionId: z.ZodString;
@@ -4303,8 +4536,8 @@ export declare const contractForDocs: {
4303
4536
  environmentId: z.ZodString;
4304
4537
  content: z.ZodString;
4305
4538
  source: z.ZodEnum<{
4306
- model: "model";
4307
4539
  user: "user";
4540
+ model: "model";
4308
4541
  }>;
4309
4542
  clientName: z.ZodNullable<z.ZodString>;
4310
4543
  clientId: z.ZodNullable<z.ZodString>;
@@ -4539,6 +4772,206 @@ export declare const contractForDocs: {
4539
4772
  }>, Record<never, never>>;
4540
4773
  };
4541
4774
  };
4775
+ telemetryDestinations: {
4776
+ list: {
4777
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
4778
+ environmentId: z.ZodString;
4779
+ }, z.core.$strip>, z.ZodArray<z.ZodObject<{
4780
+ id: z.ZodString;
4781
+ signal: z.ZodEnum<{
4782
+ logs: "logs";
4783
+ metrics: "metrics";
4784
+ traces: "traces";
4785
+ }>;
4786
+ endpoint: z.ZodString;
4787
+ protocol: z.ZodEnum<{
4788
+ "http/protobuf": "http/protobuf";
4789
+ "http/json": "http/json";
4790
+ }>;
4791
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
4792
+ id: z.ZodString;
4793
+ name: z.ZodString;
4794
+ value: z.ZodNull;
4795
+ isSecret: z.ZodLiteral<true>;
4796
+ }, z.core.$strip>, z.ZodObject<{
4797
+ id: z.ZodString;
4798
+ name: z.ZodString;
4799
+ value: z.ZodString;
4800
+ isSecret: z.ZodLiteral<false>;
4801
+ }, z.core.$strip>], "isSecret">>;
4802
+ status: z.ZodEnum<{
4803
+ active: "active";
4804
+ suspended: "suspended";
4805
+ }>;
4806
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
4807
+ credentials: "credentials";
4808
+ "wrong-path": "wrong-path";
4809
+ "wrong-protocol": "wrong-protocol";
4810
+ "invalid-payload": "invalid-payload";
4811
+ "partial-rejection": "partial-rejection";
4812
+ "blocked-target": "blocked-target";
4813
+ timeout: "timeout";
4814
+ unreachable: "unreachable";
4815
+ "receiver-error": "receiver-error";
4816
+ "unexpected-status": "unexpected-status";
4817
+ }>>;
4818
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
4819
+ }, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
4820
+ BAD_REQUEST: {};
4821
+ }>, {
4822
+ NOT_FOUND: {};
4823
+ }>, Record<never, never>>;
4824
+ };
4825
+ create: {
4826
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
4827
+ environmentId: z.ZodString;
4828
+ signal: z.ZodEnum<{
4829
+ logs: "logs";
4830
+ metrics: "metrics";
4831
+ traces: "traces";
4832
+ }>;
4833
+ endpoint: z.ZodString;
4834
+ protocol: z.ZodDefault<z.ZodEnum<{
4835
+ "http/protobuf": "http/protobuf";
4836
+ "http/json": "http/json";
4837
+ }>>;
4838
+ isScopedToIntentionalRequestsOnly: z.ZodDefault<z.ZodBoolean>;
4839
+ headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
4840
+ name: z.ZodString;
4841
+ value: z.ZodString;
4842
+ isSecret: z.ZodBoolean;
4843
+ }, z.core.$strip>>>;
4844
+ }, z.core.$strip>, z.ZodObject<{
4845
+ id: z.ZodString;
4846
+ signal: z.ZodEnum<{
4847
+ logs: "logs";
4848
+ metrics: "metrics";
4849
+ traces: "traces";
4850
+ }>;
4851
+ endpoint: z.ZodString;
4852
+ protocol: z.ZodEnum<{
4853
+ "http/protobuf": "http/protobuf";
4854
+ "http/json": "http/json";
4855
+ }>;
4856
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
4857
+ id: z.ZodString;
4858
+ name: z.ZodString;
4859
+ value: z.ZodNull;
4860
+ isSecret: z.ZodLiteral<true>;
4861
+ }, z.core.$strip>, z.ZodObject<{
4862
+ id: z.ZodString;
4863
+ name: z.ZodString;
4864
+ value: z.ZodString;
4865
+ isSecret: z.ZodLiteral<false>;
4866
+ }, z.core.$strip>], "isSecret">>;
4867
+ status: z.ZodEnum<{
4868
+ active: "active";
4869
+ suspended: "suspended";
4870
+ }>;
4871
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
4872
+ credentials: "credentials";
4873
+ "wrong-path": "wrong-path";
4874
+ "wrong-protocol": "wrong-protocol";
4875
+ "invalid-payload": "invalid-payload";
4876
+ "partial-rejection": "partial-rejection";
4877
+ "blocked-target": "blocked-target";
4878
+ timeout: "timeout";
4879
+ unreachable: "unreachable";
4880
+ "receiver-error": "receiver-error";
4881
+ "unexpected-status": "unexpected-status";
4882
+ }>>;
4883
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
4884
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
4885
+ BAD_REQUEST: {};
4886
+ }>, {
4887
+ NOT_FOUND: {};
4888
+ FORBIDDEN: {};
4889
+ OTLP_DESTINATION_UNVERIFIED: {
4890
+ status: number;
4891
+ };
4892
+ INTERNAL_SERVER_ERROR: {};
4893
+ }>, Record<never, never>>;
4894
+ };
4895
+ update: {
4896
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
4897
+ environmentId: z.ZodString;
4898
+ destinationId: z.ZodString;
4899
+ endpoint: z.ZodOptional<z.ZodString>;
4900
+ protocol: z.ZodOptional<z.ZodEnum<{
4901
+ "http/protobuf": "http/protobuf";
4902
+ "http/json": "http/json";
4903
+ }>>;
4904
+ isScopedToIntentionalRequestsOnly: z.ZodOptional<z.ZodBoolean>;
4905
+ headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
4906
+ id: z.ZodOptional<z.ZodString>;
4907
+ name: z.ZodString;
4908
+ value: z.ZodOptional<z.ZodString>;
4909
+ isSecret: z.ZodBoolean;
4910
+ }, z.core.$strip>>>;
4911
+ }, z.core.$strip>, z.ZodObject<{
4912
+ id: z.ZodString;
4913
+ signal: z.ZodEnum<{
4914
+ logs: "logs";
4915
+ metrics: "metrics";
4916
+ traces: "traces";
4917
+ }>;
4918
+ endpoint: z.ZodString;
4919
+ protocol: z.ZodEnum<{
4920
+ "http/protobuf": "http/protobuf";
4921
+ "http/json": "http/json";
4922
+ }>;
4923
+ headers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
4924
+ id: z.ZodString;
4925
+ name: z.ZodString;
4926
+ value: z.ZodNull;
4927
+ isSecret: z.ZodLiteral<true>;
4928
+ }, z.core.$strip>, z.ZodObject<{
4929
+ id: z.ZodString;
4930
+ name: z.ZodString;
4931
+ value: z.ZodString;
4932
+ isSecret: z.ZodLiteral<false>;
4933
+ }, z.core.$strip>], "isSecret">>;
4934
+ status: z.ZodEnum<{
4935
+ active: "active";
4936
+ suspended: "suspended";
4937
+ }>;
4938
+ lastFailureReason: z.ZodNullable<z.ZodEnum<{
4939
+ credentials: "credentials";
4940
+ "wrong-path": "wrong-path";
4941
+ "wrong-protocol": "wrong-protocol";
4942
+ "invalid-payload": "invalid-payload";
4943
+ "partial-rejection": "partial-rejection";
4944
+ "blocked-target": "blocked-target";
4945
+ timeout: "timeout";
4946
+ unreachable: "unreachable";
4947
+ "receiver-error": "receiver-error";
4948
+ "unexpected-status": "unexpected-status";
4949
+ }>>;
4950
+ isScopedToIntentionalRequestsOnly: z.ZodBoolean;
4951
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
4952
+ BAD_REQUEST: {};
4953
+ }>, {
4954
+ NOT_FOUND: {};
4955
+ FORBIDDEN: {};
4956
+ OTLP_DESTINATION_UNVERIFIED: {
4957
+ status: number;
4958
+ };
4959
+ }>, Record<never, never>>;
4960
+ };
4961
+ delete: {
4962
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
4963
+ environmentId: z.ZodString;
4964
+ destinationId: z.ZodString;
4965
+ }, z.core.$strip>, z.ZodObject<{
4966
+ success: z.ZodLiteral<true>;
4967
+ }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
4968
+ BAD_REQUEST: {};
4969
+ }>, {
4970
+ NOT_FOUND: {};
4971
+ INTERNAL_SERVER_ERROR: {};
4972
+ }>, Record<never, never>>;
4973
+ };
4974
+ };
4542
4975
  projects: {
4543
4976
  update: {
4544
4977
  v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -4555,6 +4988,7 @@ export declare const contractForDocs: {
4555
4988
  "python3.14": "python3.14";
4556
4989
  node22: "node22";
4557
4990
  node24: "node24";
4991
+ node26: "node26";
4558
4992
  }>;
4559
4993
  transport: z.ZodNullable<z.ZodEnum<{
4560
4994
  stdio: "stdio";
@@ -4633,6 +5067,7 @@ export declare const contractForDocs: {
4633
5067
  "python3.14": "python3.14";
4634
5068
  node22: "node22";
4635
5069
  node24: "node24";
5070
+ node26: "node26";
4636
5071
  }>;
4637
5072
  transport: z.ZodNullable<z.ZodEnum<{
4638
5073
  stdio: "stdio";
@@ -4710,6 +5145,7 @@ export declare const contractForDocs: {
4710
5145
  "python3.14": "python3.14";
4711
5146
  node22: "node22";
4712
5147
  node24: "node24";
5148
+ node26: "node26";
4713
5149
  }>;
4714
5150
  transport: z.ZodNullable<z.ZodEnum<{
4715
5151
  stdio: "stdio";
@@ -4785,6 +5221,7 @@ export declare const contractForDocs: {
4785
5221
  "python3.14": "python3.14";
4786
5222
  node22: "node22";
4787
5223
  node24: "node24";
5224
+ node26: "node26";
4788
5225
  }>;
4789
5226
  transport: z.ZodOptional<z.ZodEnum<{
4790
5227
  stdio: "stdio";
@@ -4821,6 +5258,7 @@ export declare const contractForDocs: {
4821
5258
  "python3.14": "python3.14";
4822
5259
  node22: "node22";
4823
5260
  node24: "node24";
5261
+ node26: "node26";
4824
5262
  }>;
4825
5263
  transport: z.ZodNullable<z.ZodEnum<{
4826
5264
  stdio: "stdio";
@@ -5135,6 +5573,20 @@ export declare const contractForDocs: {
5135
5573
  NOT_FOUND: {};
5136
5574
  }>, Record<never, never>>;
5137
5575
  };
5576
+ list: {
5577
+ v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
5578
+ projectId: z.ZodString;
5579
+ environmentId: z.ZodOptional<z.ZodString>;
5580
+ platform: z.ZodOptional<z.ZodEnum<{
5581
+ chatgpt: "chatgpt";
5582
+ claudeai: "claudeai";
5583
+ }>>;
5584
+ }, z.core.$strip>, z.ZodArray<z.ZodType<Submission, unknown, z.core.$ZodTypeInternals<Submission, unknown>>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
5585
+ BAD_REQUEST: {};
5586
+ }>, {
5587
+ NOT_FOUND: {};
5588
+ }>, Record<never, never>>;
5589
+ };
5138
5590
  get: {
5139
5591
  v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
5140
5592
  submissionId: z.ZodString;
@@ -5814,7 +6266,7 @@ export type RouteAuthMeta = {
5814
6266
  authScope?: AuthScope;
5815
6267
  };
5816
6268
  //#endregion
5817
- //#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/promisable.d.ts
6269
+ //#region ../../node_modules/.pnpm/type-fest@5.10.0/node_modules/type-fest/source/promisable.d.ts
5818
6270
  /**
5819
6271
  Create a type that represents either the value or the value wrapped in `PromiseLike`.
5820
6272
 
@@ -5841,11 +6293,11 @@ await logger(() => Promise.resolve('bar'));
5841
6293
  */
5842
6294
  type Promisable<T> = T | PromiseLike<T>;
5843
6295
  //#endregion
5844
- //#region ../../node_modules/.pnpm/@orpc+shared@1.15.0_@opentelemetry+api@1.9.1/node_modules/@orpc/shared/dist/index.d.mts
6296
+ //#region ../../node_modules/.pnpm/@orpc+shared@1.15.7_@opentelemetry+api@1.9.1/node_modules/@orpc/shared/dist/index.d.mts
5845
6297
  type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
5846
6298
  type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
5847
6299
  //#endregion
5848
- //#region ../../node_modules/.pnpm/@orpc+client@1.15.0_@opentelemetry+api@1.9.1/node_modules/@orpc/client/dist/index.d.mts
6300
+ //#region ../../node_modules/.pnpm/@orpc+client@1.15.7_@opentelemetry+api@1.9.1/node_modules/@orpc/client/dist/index.d.mts
5849
6301
  declare const COMMON_ORPC_ERROR_DEFS: {
5850
6302
  readonly BAD_REQUEST: {
5851
6303
  readonly status: 400;
@@ -5958,7 +6410,7 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
5958
6410
  }
5959
6411
  type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
5960
6412
  //#endregion
5961
- //#region ../../node_modules/.pnpm/@orpc+server@1.15.0_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/server/dist/shared/server.qKsRrdxW.d.mts
6413
+ //#region ../../node_modules/.pnpm/@orpc+server@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/server/dist/shared/server.qKsRrdxW.d.mts
5962
6414
  type Context = Record<PropertyKey, any>;
5963
6415
  type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
5964
6416
  type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
@@ -6029,7 +6481,7 @@ interface Middleware<TInContext extends Context, TOutContext extends Context, TI
6029
6481
  }
6030
6482
  type AnyMiddleware = Middleware<any, any, any, any, any, any>;
6031
6483
  //#endregion
6032
- //#region ../../node_modules/.pnpm/@orpc+server@1.15.0_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/server/dist/shared/server.C8_sRzQB.d.mts
6484
+ //#region ../../node_modules/.pnpm/@orpc+server@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/server/dist/shared/server.C8_sRzQB.d.mts
6033
6485
  interface TraverseContractProcedureCallbackOptions {
6034
6486
  contract: AnyContractProcedure | AnyProcedure;
6035
6487
  path: readonly string[];
@@ -6038,976 +6490,976 @@ interface TraverseContractProcedureCallbackOptions {
6038
6490
  //#region ../../node_modules/.pnpm/json-schema-typed@8.0.2/node_modules/json-schema-typed/draft_2020_12.d.ts
6039
6491
  type MaybeReadonlyArray<T> = Array<T> | ReadonlyArray<T>;
6040
6492
  type ValueOf<T> = T[keyof T];
6041
- /**
6042
- * JSON Schema [Draft 2020-12](https://json-schema.org/draft/2020-12/json-schema-validation.html)
6493
+ /**
6494
+ * JSON Schema [Draft 2020-12](https://json-schema.org/draft/2020-12/json-schema-validation.html)
6043
6495
  */
6044
6496
  type JSONSchema<Value = any, SchemaType = Value extends boolean ? "boolean" : Value extends null ? "null" : Value extends number ? "number" | "integer" : Value extends string ? "string" : Value extends unknown[] ? "array" : Value extends Record<string | number, unknown> ? "object" : JSONSchema.TypeValue> = boolean | {
6045
- /**
6046
- * Using JSON Pointer fragments requires knowledge of the structure of the
6047
- * schema. When writing schema documents with the intention to provide
6048
- * re-usable schemas, it may be preferable to use a plain name fragment
6049
- * that is not tied to any particular structural location. This allows a
6050
- * subschema to be relocated without requiring JSON Pointer references to
6051
- * be updated.
6052
- *
6053
- * The `$anchor` keyword is used to specify such a fragment. It is an
6054
- * identifier keyword that can only be used to create plain name fragments.
6055
- *
6056
- * If present, the value of this keyword MUST be a string, which MUST start
6057
- * with a letter `[A-Za-z]`, followed by any number of letters, digits
6058
- * `[0-9]`, hyphens `-`, underscores `_`, colons `:`,
6059
- * or periods `.`.
6060
- *
6061
- * Note that the anchor string does not include the `#` character,
6062
- * as it is not a URI-reference. An `{"$anchor": "foo"}` becomes the
6063
- * fragment `#foo` when used in a URI.
6064
- *
6065
- * The base URI to which the resulting fragment is appended is determined
6066
- * by the `$id` keyword as explained in the previous section.
6067
- * Two `$anchor` keywords in the same schema document MAY have the same
6068
- * value if they apply to different base URIs, as the resulting full URIs
6069
- * will be distinct. However, the effect of two `$anchor` keywords
6070
- * with the same value and the same base URI is undefined. Implementations
6071
- * MAY raise an error if such usage is detected.
6497
+ /**
6498
+ * Using JSON Pointer fragments requires knowledge of the structure of the
6499
+ * schema. When writing schema documents with the intention to provide
6500
+ * re-usable schemas, it may be preferable to use a plain name fragment
6501
+ * that is not tied to any particular structural location. This allows a
6502
+ * subschema to be relocated without requiring JSON Pointer references to
6503
+ * be updated.
6504
+ *
6505
+ * The `$anchor` keyword is used to specify such a fragment. It is an
6506
+ * identifier keyword that can only be used to create plain name fragments.
6507
+ *
6508
+ * If present, the value of this keyword MUST be a string, which MUST start
6509
+ * with a letter `[A-Za-z]`, followed by any number of letters, digits
6510
+ * `[0-9]`, hyphens `-`, underscores `_`, colons `:`,
6511
+ * or periods `.`.
6512
+ *
6513
+ * Note that the anchor string does not include the `#` character,
6514
+ * as it is not a URI-reference. An `{"$anchor": "foo"}` becomes the
6515
+ * fragment `#foo` when used in a URI.
6516
+ *
6517
+ * The base URI to which the resulting fragment is appended is determined
6518
+ * by the `$id` keyword as explained in the previous section.
6519
+ * Two `$anchor` keywords in the same schema document MAY have the same
6520
+ * value if they apply to different base URIs, as the resulting full URIs
6521
+ * will be distinct. However, the effect of two `$anchor` keywords
6522
+ * with the same value and the same base URI is undefined. Implementations
6523
+ * MAY raise an error if such usage is detected.
6072
6524
  */
6073
6525
  $anchor?: string;
6074
- /**
6075
- * This keyword reserves a location for comments from schema authors to
6076
- * readers or maintainers of the schema.
6077
- *
6078
- * The value of this keyword MUST be a string. Implementations MUST NOT
6079
- * present this string to end users. Tools for editing schemas SHOULD
6080
- * support displaying and editing this keyword. The value of this keyword
6081
- * MAY be used in debug or error output which is intended for developers
6082
- * making use of schemas.
6083
- *
6084
- * Schema vocabularies SHOULD allow `$comment` within any object
6085
- * containing vocabulary keywords. Implementations MAY assume `$comment`
6086
- * is allowed unless the vocabulary specifically forbids it. Vocabularies
6087
- * MUST NOT specify any effect of `$comment` beyond what is described in
6088
- * this specification.
6089
- *
6090
- * Tools that translate other media types or programming languages
6091
- * to and from `application/schema+json` MAY choose to convert that media
6092
- * type or programming language's native comments to or from `$comment`
6093
- * values. The behavior of such translation when both native comments and
6094
- * `$comment` properties are present is implementation-dependent.
6095
- *
6096
- * Implementations MAY strip `$comment` values at any point during
6097
- * processing. In particular, this allows for shortening schemas when the
6098
- * size of deployed schemas is a concern.
6099
- *
6100
- * Implementations MUST NOT take any other action based on the presence,
6101
- * absence, or contents of `$comment` properties. In particular, the
6102
- * value of `$comment` MUST NOT be collected as an annotation result.
6526
+ /**
6527
+ * This keyword reserves a location for comments from schema authors to
6528
+ * readers or maintainers of the schema.
6529
+ *
6530
+ * The value of this keyword MUST be a string. Implementations MUST NOT
6531
+ * present this string to end users. Tools for editing schemas SHOULD
6532
+ * support displaying and editing this keyword. The value of this keyword
6533
+ * MAY be used in debug or error output which is intended for developers
6534
+ * making use of schemas.
6535
+ *
6536
+ * Schema vocabularies SHOULD allow `$comment` within any object
6537
+ * containing vocabulary keywords. Implementations MAY assume `$comment`
6538
+ * is allowed unless the vocabulary specifically forbids it. Vocabularies
6539
+ * MUST NOT specify any effect of `$comment` beyond what is described in
6540
+ * this specification.
6541
+ *
6542
+ * Tools that translate other media types or programming languages
6543
+ * to and from `application/schema+json` MAY choose to convert that media
6544
+ * type or programming language's native comments to or from `$comment`
6545
+ * values. The behavior of such translation when both native comments and
6546
+ * `$comment` properties are present is implementation-dependent.
6547
+ *
6548
+ * Implementations MAY strip `$comment` values at any point during
6549
+ * processing. In particular, this allows for shortening schemas when the
6550
+ * size of deployed schemas is a concern.
6551
+ *
6552
+ * Implementations MUST NOT take any other action based on the presence,
6553
+ * absence, or contents of `$comment` properties. In particular, the
6554
+ * value of `$comment` MUST NOT be collected as an annotation result.
6103
6555
  */
6104
6556
  $comment?: string;
6105
- /**
6106
- * The `$defs` keyword reserves a location for schema authors to inline
6107
- * re-usable JSON Schemas into a more general schema. The keyword does not
6108
- * directly affect the validation result.
6109
- *
6110
- * This keyword's value MUST be an object. Each member value of this object
6111
- * MUST be a valid JSON Schema.
6557
+ /**
6558
+ * The `$defs` keyword reserves a location for schema authors to inline
6559
+ * re-usable JSON Schemas into a more general schema. The keyword does not
6560
+ * directly affect the validation result.
6561
+ *
6562
+ * This keyword's value MUST be an object. Each member value of this object
6563
+ * MUST be a valid JSON Schema.
6112
6564
  */
6113
6565
  $defs?: Record<string, JSONSchema>;
6114
- /**
6115
- * "The `$dynamicAnchor` indicates that the fragment is an extension
6116
- * point when used with the `$dynamicRef` keyword. This low-level,
6117
- * advanced feature makes it easier to extend recursive schemas such as the
6118
- * meta-schemas, without imposing any particular semantics on that
6119
- * extension. See `$dynamicRef` for more details.
6566
+ /**
6567
+ * "The `$dynamicAnchor` indicates that the fragment is an extension
6568
+ * point when used with the `$dynamicRef` keyword. This low-level,
6569
+ * advanced feature makes it easier to extend recursive schemas such as the
6570
+ * meta-schemas, without imposing any particular semantics on that
6571
+ * extension. See `$dynamicRef` for more details.
6120
6572
  */
6121
6573
  $dynamicAnchor?: string;
6122
- /**
6123
- * The `$dynamicRef` keyword is an applicator that allows for deferring
6124
- * the full resolution until runtime, at which point it is resolved each
6125
- * time it is encountered while evaluating an instance.
6126
- *
6127
- * Together with `$dynamicAnchor`, `$dynamicRef` implements a
6128
- * cooperative extension mechanism that is primarily useful with recursive
6129
- * schemas (schemas that reference themselves). Both the extension point
6130
- * and the runtime-determined extension target are defined with
6131
- * `$dynamicAnchor`, and only exhibit runtime dynamic behavior when
6132
- * referenced with `$dynamicRef`.
6133
- *
6134
- * The value of the `$dynamicRef` property MUST be a string which is
6135
- * a URI-Reference. Resolved against the current URI base, it produces
6136
- * the URI used as the starting point for runtime resolution. This initial
6137
- * resolution is safe to perform on schema load.
6138
- *
6139
- * If the initially resolved starting point URI includes a fragment that
6140
- * was created by the `$dynamicAnchor` keyword, the initial URI MUST be
6141
- * replaced by the URI (including the fragment) for the outermost schema
6142
- * resource in the [dynamic scope][scopes] that defines
6143
- * an identically named fragment with `$dynamicAnchor`.
6144
- *
6145
- * Otherwise, its behavior is identical to `$ref`, and no runtime
6146
- * resolution is needed.
6147
- *
6148
- * [scopes]: https://json-schema.org/draft/2020-12/json-schema-core.html#scopes
6149
- *
6150
- * @format "uri-reference"
6574
+ /**
6575
+ * The `$dynamicRef` keyword is an applicator that allows for deferring
6576
+ * the full resolution until runtime, at which point it is resolved each
6577
+ * time it is encountered while evaluating an instance.
6578
+ *
6579
+ * Together with `$dynamicAnchor`, `$dynamicRef` implements a
6580
+ * cooperative extension mechanism that is primarily useful with recursive
6581
+ * schemas (schemas that reference themselves). Both the extension point
6582
+ * and the runtime-determined extension target are defined with
6583
+ * `$dynamicAnchor`, and only exhibit runtime dynamic behavior when
6584
+ * referenced with `$dynamicRef`.
6585
+ *
6586
+ * The value of the `$dynamicRef` property MUST be a string which is
6587
+ * a URI-Reference. Resolved against the current URI base, it produces
6588
+ * the URI used as the starting point for runtime resolution. This initial
6589
+ * resolution is safe to perform on schema load.
6590
+ *
6591
+ * If the initially resolved starting point URI includes a fragment that
6592
+ * was created by the `$dynamicAnchor` keyword, the initial URI MUST be
6593
+ * replaced by the URI (including the fragment) for the outermost schema
6594
+ * resource in the [dynamic scope][scopes] that defines
6595
+ * an identically named fragment with `$dynamicAnchor`.
6596
+ *
6597
+ * Otherwise, its behavior is identical to `$ref`, and no runtime
6598
+ * resolution is needed.
6599
+ *
6600
+ * [scopes]: https://json-schema.org/draft/2020-12/json-schema-core.html#scopes
6601
+ *
6602
+ * @format "uri-reference"
6151
6603
  */
6152
6604
  $dynamicRef?: string;
6153
- /**
6154
- * The `$id` keyword identifies a schema resource with its
6155
- * [canonical][[RFC6596]] URI.
6156
- *
6157
- * Note that this URI is an identifier and not necessarily a network
6158
- * locator. In the case of a network-addressable URL, a schema need not be
6159
- * downloadable from its canonical URI.
6160
- *
6161
- * If present, the value for this keyword MUST be a string, and MUST
6162
- * represent a valid [URI-reference][RFC3986]. This URI-reference SHOULD
6163
- * be normalized, and MUST resolve to an [absolute-URI][RFC3986] (without a
6164
- * fragment). Therefore, `$id` MUST NOT contain a non-empty fragment,
6165
- * and SHOULD NOT contain an empty fragment.
6166
- *
6167
- * Since an empty fragment in the context of the
6168
- * `application/schema+json` media type refers to the same resource as
6169
- * the base URI without a fragment, an implementation MAY normalize a URI
6170
- * ending with an empty fragment by removing the fragment. However, schema
6171
- * authors SHOULD NOT rely on this behavior across implementations.
6172
- *
6173
- * This URI also serves as the base URI for relative URI-references in
6174
- * keywords within the schema resource, in accordance with
6175
- * [RFC 3986][RFC3986] section 5.1.1 regarding base URIs embedded in
6176
- * content.
6177
- *
6178
- * The presence of `$id` in a subschema indicates that the subschema
6179
- * constitutes a distinct schema resource within a single schema document.
6180
- * Furthermore, in accordance with [RFC 3986][RFC3986] section 5.1.2
6181
- * regarding encapsulating entities, if an `$id` in a subschema is a
6182
- * relative URI-reference, the base URI for resolving that reference is the
6183
- * URI of the parent schema resource.
6184
- *
6185
- * If no parent schema object explicitly identifies itself as a resource
6186
- * with `$id`, the base URI is that of the entire document.
6187
- *
6188
- * The root schema of a JSON Schema document SHOULD contain an `$id`
6189
- * keyword with an [absolute-URI][RFC3986] (containing a scheme, but no
6190
- * fragment).
6191
- *
6192
- * [RFC6596]: https://datatracker.ietf.org/doc/html/rfc6596
6193
- * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
6194
- *
6195
- * @format "uri-reference"
6605
+ /**
6606
+ * The `$id` keyword identifies a schema resource with its
6607
+ * [canonical][[RFC6596]] URI.
6608
+ *
6609
+ * Note that this URI is an identifier and not necessarily a network
6610
+ * locator. In the case of a network-addressable URL, a schema need not be
6611
+ * downloadable from its canonical URI.
6612
+ *
6613
+ * If present, the value for this keyword MUST be a string, and MUST
6614
+ * represent a valid [URI-reference][RFC3986]. This URI-reference SHOULD
6615
+ * be normalized, and MUST resolve to an [absolute-URI][RFC3986] (without a
6616
+ * fragment). Therefore, `$id` MUST NOT contain a non-empty fragment,
6617
+ * and SHOULD NOT contain an empty fragment.
6618
+ *
6619
+ * Since an empty fragment in the context of the
6620
+ * `application/schema+json` media type refers to the same resource as
6621
+ * the base URI without a fragment, an implementation MAY normalize a URI
6622
+ * ending with an empty fragment by removing the fragment. However, schema
6623
+ * authors SHOULD NOT rely on this behavior across implementations.
6624
+ *
6625
+ * This URI also serves as the base URI for relative URI-references in
6626
+ * keywords within the schema resource, in accordance with
6627
+ * [RFC 3986][RFC3986] section 5.1.1 regarding base URIs embedded in
6628
+ * content.
6629
+ *
6630
+ * The presence of `$id` in a subschema indicates that the subschema
6631
+ * constitutes a distinct schema resource within a single schema document.
6632
+ * Furthermore, in accordance with [RFC 3986][RFC3986] section 5.1.2
6633
+ * regarding encapsulating entities, if an `$id` in a subschema is a
6634
+ * relative URI-reference, the base URI for resolving that reference is the
6635
+ * URI of the parent schema resource.
6636
+ *
6637
+ * If no parent schema object explicitly identifies itself as a resource
6638
+ * with `$id`, the base URI is that of the entire document.
6639
+ *
6640
+ * The root schema of a JSON Schema document SHOULD contain an `$id`
6641
+ * keyword with an [absolute-URI][RFC3986] (containing a scheme, but no
6642
+ * fragment).
6643
+ *
6644
+ * [RFC6596]: https://datatracker.ietf.org/doc/html/rfc6596
6645
+ * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
6646
+ *
6647
+ * @format "uri-reference"
6196
6648
  */
6197
6649
  $id?: string;
6198
- /**
6199
- * The `$ref` keyword is an applicator that is used to reference a
6200
- * statically identified schema. Its results are the results of the
6201
- * referenced schema. Other keywords can appear alongside of `$ref` in
6202
- * the same schema object.
6203
- *
6204
- * The value of the `$ref` property MUST be a string which is a
6205
- * URI-Reference. Resolved against the current URI base, it produces the
6206
- * URI of the schema to apply.
6207
- *
6208
- * @format "uri-reference"
6650
+ /**
6651
+ * The `$ref` keyword is an applicator that is used to reference a
6652
+ * statically identified schema. Its results are the results of the
6653
+ * referenced schema. Other keywords can appear alongside of `$ref` in
6654
+ * the same schema object.
6655
+ *
6656
+ * The value of the `$ref` property MUST be a string which is a
6657
+ * URI-Reference. Resolved against the current URI base, it produces the
6658
+ * URI of the schema to apply.
6659
+ *
6660
+ * @format "uri-reference"
6209
6661
  */
6210
6662
  $ref?: string;
6211
- /**
6212
- * The `$schema` keyword is both used as a JSON Schema dialect identifier
6213
- * and as the identifier of a resource which is itself a JSON Schema, which
6214
- * describes the set of valid schemas written for this particular dialect.
6215
- *
6216
- * The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
6217
- * and this URI MUST be normalized. The current schema MUST be valid
6218
- * against the meta-schema identified by this URI.
6219
- *
6220
- * If this URI identifies a retrievable resource, that resource SHOULD be
6221
- * of media type `application/schema+json`.
6222
- *
6223
- * The `$schema` keyword SHOULD be used in the document root schema
6224
- * object, and MAY be used in the root schema objects of embedded schema
6225
- * resources. It MUST NOT appear in non-resource root schema objects. If
6226
- * absent from the document root schema, the resulting behavior is
6227
- * implementation-defined.
6228
- *
6229
- * Values for this property are defined elsewhere in this and other
6230
- * documents, and by other parties.
6231
- *
6232
- * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
6233
- *
6234
- * @format "uri"
6663
+ /**
6664
+ * The `$schema` keyword is both used as a JSON Schema dialect identifier
6665
+ * and as the identifier of a resource which is itself a JSON Schema, which
6666
+ * describes the set of valid schemas written for this particular dialect.
6667
+ *
6668
+ * The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
6669
+ * and this URI MUST be normalized. The current schema MUST be valid
6670
+ * against the meta-schema identified by this URI.
6671
+ *
6672
+ * If this URI identifies a retrievable resource, that resource SHOULD be
6673
+ * of media type `application/schema+json`.
6674
+ *
6675
+ * The `$schema` keyword SHOULD be used in the document root schema
6676
+ * object, and MAY be used in the root schema objects of embedded schema
6677
+ * resources. It MUST NOT appear in non-resource root schema objects. If
6678
+ * absent from the document root schema, the resulting behavior is
6679
+ * implementation-defined.
6680
+ *
6681
+ * Values for this property are defined elsewhere in this and other
6682
+ * documents, and by other parties.
6683
+ *
6684
+ * [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
6685
+ *
6686
+ * @format "uri"
6235
6687
  */
6236
6688
  $schema?: string;
6237
- /**
6238
- * The `$vocabulary` keyword is used in meta-schemas to identify the
6239
- * vocabularies available for use in schemas described by that meta-schema.
6240
- * It is also used to indicate whether each vocabulary is required or
6241
- * optional, in the sense that an implementation MUST understand the
6242
- * required vocabularies in order to successfully process the schema.
6243
- * Together, this information forms a dialect. Any vocabulary that is
6244
- * understood by the implementation MUST be processed in a manner
6245
- * consistent with the semantic definitions contained within the
6246
- * vocabulary.
6247
- *
6248
- * The value of this keyword MUST be an object. The property names in the
6249
- * object MUST be URIs (containing a scheme) and this URI MUST be
6250
- * normalized. Each URI that appears as a property name identifies a
6251
- * specific set of keywords and their semantics.
6252
- *
6253
- * The URI MAY be a URL, but the nature of the retrievable resource is
6254
- * currently undefined, and reserved for future use. Vocabulary authors
6255
- * MAY use the URL of the vocabulary specification, in a human-readable
6256
- * media type such as `text/html` or `text/plain`, as the vocabulary
6257
- * URI.
6258
- *
6259
- * The values of the object properties MUST be booleans. If the value is
6260
- * `true`, then implementations that do not recognize the vocabulary MUST
6261
- * refuse to process any schemas that declare this meta-schema with
6262
- * `$schema`. If the value is `false`, implementations that do not
6263
- * recognize the vocabulary SHOULD proceed with processing such schemas.
6264
- * The value has no impact if the implementation understands the
6265
- * vocabulary.
6266
- *
6267
- * Unrecognized keywords SHOULD be ignored. This remains the case for
6268
- * keywords defined by unrecognized vocabularies. It is not currently
6269
- * possible to distinguish between unrecognized keywords that are defined
6270
- * in vocabularies from those that are not part of any vocabulary.
6271
- *
6272
- * The `$vocabulary` keyword SHOULD be used in the root schema of any
6273
- * schema document intended for use as a meta-schema. It MUST NOT appear
6274
- * in subschemas.
6275
- *
6276
- * The `$vocabulary` keyword MUST be ignored in schema documents that are
6277
- * not being processed as a meta-schema.
6689
+ /**
6690
+ * The `$vocabulary` keyword is used in meta-schemas to identify the
6691
+ * vocabularies available for use in schemas described by that meta-schema.
6692
+ * It is also used to indicate whether each vocabulary is required or
6693
+ * optional, in the sense that an implementation MUST understand the
6694
+ * required vocabularies in order to successfully process the schema.
6695
+ * Together, this information forms a dialect. Any vocabulary that is
6696
+ * understood by the implementation MUST be processed in a manner
6697
+ * consistent with the semantic definitions contained within the
6698
+ * vocabulary.
6699
+ *
6700
+ * The value of this keyword MUST be an object. The property names in the
6701
+ * object MUST be URIs (containing a scheme) and this URI MUST be
6702
+ * normalized. Each URI that appears as a property name identifies a
6703
+ * specific set of keywords and their semantics.
6704
+ *
6705
+ * The URI MAY be a URL, but the nature of the retrievable resource is
6706
+ * currently undefined, and reserved for future use. Vocabulary authors
6707
+ * MAY use the URL of the vocabulary specification, in a human-readable
6708
+ * media type such as `text/html` or `text/plain`, as the vocabulary
6709
+ * URI.
6710
+ *
6711
+ * The values of the object properties MUST be booleans. If the value is
6712
+ * `true`, then implementations that do not recognize the vocabulary MUST
6713
+ * refuse to process any schemas that declare this meta-schema with
6714
+ * `$schema`. If the value is `false`, implementations that do not
6715
+ * recognize the vocabulary SHOULD proceed with processing such schemas.
6716
+ * The value has no impact if the implementation understands the
6717
+ * vocabulary.
6718
+ *
6719
+ * Unrecognized keywords SHOULD be ignored. This remains the case for
6720
+ * keywords defined by unrecognized vocabularies. It is not currently
6721
+ * possible to distinguish between unrecognized keywords that are defined
6722
+ * in vocabularies from those that are not part of any vocabulary.
6723
+ *
6724
+ * The `$vocabulary` keyword SHOULD be used in the root schema of any
6725
+ * schema document intended for use as a meta-schema. It MUST NOT appear
6726
+ * in subschemas.
6727
+ *
6728
+ * The `$vocabulary` keyword MUST be ignored in schema documents that are
6729
+ * not being processed as a meta-schema.
6278
6730
  */
6279
6731
  $vocabulary?: Record<string, string>;
6280
- /**
6281
- * @deprecated `additionalItems` has been deprecated in favor of `prefixItems`
6282
- * paired with `items`.
6732
+ /**
6733
+ * @deprecated `additionalItems` has been deprecated in favor of `prefixItems`
6734
+ * paired with `items`.
6283
6735
  */
6284
6736
  additionalItems?: JSONSchema;
6285
- /**
6286
- * The value of `additionalProperties` MUST be a valid JSON Schema.
6287
- *
6288
- * The behavior of this keyword depends on the presence and annotation
6289
- * results of `properties` and `patternProperties` within the same
6290
- * schema object. Validation with `additionalProperties` applies only to
6291
- * the child values of instance names that do not appear in the annotation
6292
- * results of either `properties` or `patternProperties`.
6293
- *
6294
- * For all such properties, validation succeeds if the child instance
6295
- * validates against the `additionalProperties` schema.
6296
- *
6297
- * The annotation result of this keyword is the set of instance property
6298
- * names validated by this keyword's subschema. Annotation results for
6299
- * `additionalProperties` keywords from multiple schemas applied to the
6300
- * same instance location are combined by taking the union of the sets.
6301
- *
6302
- * Omitting this keyword has the same assertion behavior as an empty
6303
- * schema.
6304
- *
6305
- * Implementations MAY choose to implement or optimize this keyword in
6306
- * another way that produces the same effect, such as by directly checking
6307
- * the names in `properties` and the patterns in `patternProperties`
6308
- * against the instance property set.
6737
+ /**
6738
+ * The value of `additionalProperties` MUST be a valid JSON Schema.
6739
+ *
6740
+ * The behavior of this keyword depends on the presence and annotation
6741
+ * results of `properties` and `patternProperties` within the same
6742
+ * schema object. Validation with `additionalProperties` applies only to
6743
+ * the child values of instance names that do not appear in the annotation
6744
+ * results of either `properties` or `patternProperties`.
6745
+ *
6746
+ * For all such properties, validation succeeds if the child instance
6747
+ * validates against the `additionalProperties` schema.
6748
+ *
6749
+ * The annotation result of this keyword is the set of instance property
6750
+ * names validated by this keyword's subschema. Annotation results for
6751
+ * `additionalProperties` keywords from multiple schemas applied to the
6752
+ * same instance location are combined by taking the union of the sets.
6753
+ *
6754
+ * Omitting this keyword has the same assertion behavior as an empty
6755
+ * schema.
6756
+ *
6757
+ * Implementations MAY choose to implement or optimize this keyword in
6758
+ * another way that produces the same effect, such as by directly checking
6759
+ * the names in `properties` and the patterns in `patternProperties`
6760
+ * against the instance property set.
6309
6761
  */
6310
6762
  additionalProperties?: JSONSchema;
6311
- /**
6312
- * This keyword's value MUST be a non-empty array. Each item of the array
6313
- * MUST be a valid JSON Schema.
6314
- *
6315
- * An instance validates successfully against this keyword if it validates
6316
- * successfully against all schemas defined by this keyword's value.
6763
+ /**
6764
+ * This keyword's value MUST be a non-empty array. Each item of the array
6765
+ * MUST be a valid JSON Schema.
6766
+ *
6767
+ * An instance validates successfully against this keyword if it validates
6768
+ * successfully against all schemas defined by this keyword's value.
6317
6769
  */
6318
6770
  allOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
6319
- /**
6320
- * This keyword's value MUST be a non-empty array. Each item of the array
6321
- * MUST be a valid JSON Schema.
6322
- *
6323
- * An instance validates successfully against this keyword if it validates
6324
- * successfully against at least one schema defined by this keyword's
6325
- * value.
6771
+ /**
6772
+ * This keyword's value MUST be a non-empty array. Each item of the array
6773
+ * MUST be a valid JSON Schema.
6774
+ *
6775
+ * An instance validates successfully against this keyword if it validates
6776
+ * successfully against at least one schema defined by this keyword's
6777
+ * value.
6326
6778
  */
6327
6779
  anyOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
6328
- /**
6329
- * An instance validates successfully against this keyword if its value is
6330
- * equal to the value of the keyword.
6331
- *
6332
- * Use of this keyword is functionally equivalent to the `enum` keyword
6333
- * with a single value.
6780
+ /**
6781
+ * An instance validates successfully against this keyword if its value is
6782
+ * equal to the value of the keyword.
6783
+ *
6784
+ * Use of this keyword is functionally equivalent to the `enum` keyword
6785
+ * with a single value.
6334
6786
  */
6335
6787
  const?: Value;
6336
- /**
6337
- * The value of this keyword MUST be a valid JSON Schema.
6338
- *
6339
- * An array instance is valid against `contains` if at least one of its
6340
- * elements is valid against the given schema. The subschema MUST be
6341
- * applied to every array element even after the first match has been
6342
- * found, in order to collect annotations for use by other keywords.
6343
- * This is to ensure that all possible annotations are collected.
6344
- *
6345
- * Logically, the validation result of applying the value subschema to each
6346
- * item in the array MUST be OR'ed with `false`, resulting in an overall
6347
- * validation result.
6348
- *
6349
- * This keyword produces an annotation value which is an array of the
6350
- * indexes to which this keyword validates successfully when applying its
6351
- * subschema, in ascending order. The value MAY be a boolean `true` if
6352
- * the subschema validates successfully when applied to every index of the
6353
- * instance. The annotation MUST be present if the instance array to which
6354
- * this keyword's schema applies is empty.
6788
+ /**
6789
+ * The value of this keyword MUST be a valid JSON Schema.
6790
+ *
6791
+ * An array instance is valid against `contains` if at least one of its
6792
+ * elements is valid against the given schema. The subschema MUST be
6793
+ * applied to every array element even after the first match has been
6794
+ * found, in order to collect annotations for use by other keywords.
6795
+ * This is to ensure that all possible annotations are collected.
6796
+ *
6797
+ * Logically, the validation result of applying the value subschema to each
6798
+ * item in the array MUST be OR'ed with `false`, resulting in an overall
6799
+ * validation result.
6800
+ *
6801
+ * This keyword produces an annotation value which is an array of the
6802
+ * indexes to which this keyword validates successfully when applying its
6803
+ * subschema, in ascending order. The value MAY be a boolean `true` if
6804
+ * the subschema validates successfully when applied to every index of the
6805
+ * instance. The annotation MUST be present if the instance array to which
6806
+ * this keyword's schema applies is empty.
6355
6807
  */
6356
6808
  contains?: JSONSchema<Value, SchemaType>;
6357
- /**
6358
- * If the instance value is a string, this property defines that the
6359
- * string SHOULD be interpreted as binary data and decoded using the
6360
- * encoding named by this property. [RFC 2045, Sec 6.1][RFC2045] lists the
6361
- * possible values for this property.
6362
- *
6363
- * The value of this property SHOULD be ignored if the instance described
6364
- * is not a string.
6365
- *
6366
- * If this keyword is absent, but `contentMediaType` is present, this
6367
- * indicates that the media type could be encoded into `UTF-8` like any
6368
- * other JSON string value, and does not require additional decoding.
6369
- *
6370
- * The value of this property MUST be a string.
6371
- *
6372
- * [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.1
6809
+ /**
6810
+ * If the instance value is a string, this property defines that the
6811
+ * string SHOULD be interpreted as binary data and decoded using the
6812
+ * encoding named by this property. [RFC 2045, Sec 6.1][RFC2045] lists the
6813
+ * possible values for this property.
6814
+ *
6815
+ * The value of this property SHOULD be ignored if the instance described
6816
+ * is not a string.
6817
+ *
6818
+ * If this keyword is absent, but `contentMediaType` is present, this
6819
+ * indicates that the media type could be encoded into `UTF-8` like any
6820
+ * other JSON string value, and does not require additional decoding.
6821
+ *
6822
+ * The value of this property MUST be a string.
6823
+ *
6824
+ * [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.1
6373
6825
  */
6374
6826
  contentEncoding?: "7bit" | "8bit" | "base64" | "binary" | "ietf-token" | "quoted-printable" | "x-token";
6375
- /**
6376
- * If the instance is a string, this property indicates the media type
6377
- * of the contents of the string. If `contentEncoding` is present,
6378
- * this property describes the decoded string.
6379
- *
6380
- * The value of this property must be a media type, as defined by
6381
- * [RFC 2046][RFC2046]. This property defines the media type of instances
6382
- * which this schema defines.
6383
- *
6384
- * The value of this property SHOULD be ignored if the instance described
6385
- * is not a string.
6386
- *
6387
- * If the `contentEncoding` property is not present, but the instance
6388
- * value is a string, then the value of this property SHOULD specify a text
6389
- * document type, and the character set SHOULD be the character set into
6390
- * which the JSON string value was decoded (for which the default is
6391
- * Unicode).
6392
- *
6393
- * [RFC2046]: https://datatracker.ietf.org/doc/html/rfc2046
6827
+ /**
6828
+ * If the instance is a string, this property indicates the media type
6829
+ * of the contents of the string. If `contentEncoding` is present,
6830
+ * this property describes the decoded string.
6831
+ *
6832
+ * The value of this property must be a media type, as defined by
6833
+ * [RFC 2046][RFC2046]. This property defines the media type of instances
6834
+ * which this schema defines.
6835
+ *
6836
+ * The value of this property SHOULD be ignored if the instance described
6837
+ * is not a string.
6838
+ *
6839
+ * If the `contentEncoding` property is not present, but the instance
6840
+ * value is a string, then the value of this property SHOULD specify a text
6841
+ * document type, and the character set SHOULD be the character set into
6842
+ * which the JSON string value was decoded (for which the default is
6843
+ * Unicode).
6844
+ *
6845
+ * [RFC2046]: https://datatracker.ietf.org/doc/html/rfc2046
6394
6846
  */
6395
6847
  contentMediaType?: string;
6396
- /**
6397
- * If the instance is a string, and if `contentMediaType` is present,
6398
- * this property contains a schema which describes the structure of the
6399
- * string.
6400
- *
6401
- * This keyword MAY be used with any media type that can be mapped into
6402
- * JSON Schema's data model.
6403
- *
6404
- * The value of this property MUST be a valid JSON schema. It SHOULD be
6405
- * ignored if `contentMediaType` is not present.
6848
+ /**
6849
+ * If the instance is a string, and if `contentMediaType` is present,
6850
+ * this property contains a schema which describes the structure of the
6851
+ * string.
6852
+ *
6853
+ * This keyword MAY be used with any media type that can be mapped into
6854
+ * JSON Schema's data model.
6855
+ *
6856
+ * The value of this property MUST be a valid JSON schema. It SHOULD be
6857
+ * ignored if `contentMediaType` is not present.
6406
6858
  */
6407
6859
  contentSchema?: JSONSchema<Value, SchemaType>;
6408
- /**
6409
- * This keyword can be used to supply a default JSON value associated with
6410
- * a particular schema. It is RECOMMENDED that a `default` value be valid
6411
- * against the associated schema.
6860
+ /**
6861
+ * This keyword can be used to supply a default JSON value associated with
6862
+ * a particular schema. It is RECOMMENDED that a `default` value be valid
6863
+ * against the associated schema.
6412
6864
  */
6413
6865
  default?: Value;
6414
- /**
6415
- * @deprecated `definitions` has been renamed to `$defs`.
6866
+ /**
6867
+ * @deprecated `definitions` has been renamed to `$defs`.
6416
6868
  */
6417
6869
  definitions?: Record<string, JSONSchema>;
6418
- /**
6419
- * @deprecated `dependencies` has been split into two keywords:
6420
- * `dependentSchemas` and `dependentRequired`.
6870
+ /**
6871
+ * @deprecated `dependencies` has been split into two keywords:
6872
+ * `dependentSchemas` and `dependentRequired`.
6421
6873
  */
6422
6874
  dependencies?: Record<string, MaybeReadonlyArray<string> | JSONSchema>;
6423
- /**
6424
- * The value of this keyword MUST be an object. Properties in
6425
- * this object, if any, MUST be arrays. Elements in each array,
6426
- * if any, MUST be strings, and MUST be unique.
6427
- *
6428
- * This keyword specifies properties that are required if a specific
6429
- * other property is present. Their requirement is dependent on the
6430
- * presence of the other property.
6431
- *
6432
- * Validation succeeds if, for each name that appears in both
6433
- * the instance and as a name within this keyword's value, every
6434
- * item in the corresponding array is also the name of a property
6435
- * in the instance.
6436
- *
6437
- * Omitting this keyword has the same behavior as an empty object.
6875
+ /**
6876
+ * The value of this keyword MUST be an object. Properties in
6877
+ * this object, if any, MUST be arrays. Elements in each array,
6878
+ * if any, MUST be strings, and MUST be unique.
6879
+ *
6880
+ * This keyword specifies properties that are required if a specific
6881
+ * other property is present. Their requirement is dependent on the
6882
+ * presence of the other property.
6883
+ *
6884
+ * Validation succeeds if, for each name that appears in both
6885
+ * the instance and as a name within this keyword's value, every
6886
+ * item in the corresponding array is also the name of a property
6887
+ * in the instance.
6888
+ *
6889
+ * Omitting this keyword has the same behavior as an empty object.
6438
6890
  */
6439
6891
  dependentRequired?: Record<string, MaybeReadonlyArray<string>>;
6440
- /**
6441
- * This keyword specifies subschemas that are evaluated if the instance is
6442
- * an object and contains a certain property.
6443
- *
6444
- * This keyword's value MUST be an object. Each value in the object MUST be
6445
- * a valid JSON Schema.
6446
- *
6447
- * If the object key is a property in the instance, the entire instance
6448
- * must validate against the subschema. Its use is dependent on the
6449
- * presence of the property.
6450
- *
6451
- * Omitting this keyword has the same behavior as an empty object.
6892
+ /**
6893
+ * This keyword specifies subschemas that are evaluated if the instance is
6894
+ * an object and contains a certain property.
6895
+ *
6896
+ * This keyword's value MUST be an object. Each value in the object MUST be
6897
+ * a valid JSON Schema.
6898
+ *
6899
+ * If the object key is a property in the instance, the entire instance
6900
+ * must validate against the subschema. Its use is dependent on the
6901
+ * presence of the property.
6902
+ *
6903
+ * Omitting this keyword has the same behavior as an empty object.
6452
6904
  */
6453
6905
  dependentSchemas?: Record<string, JSONSchema>;
6454
- /**
6455
- * The value of this keyword MUST be a boolean. When multiple occurrences
6456
- * of this keyword are applicable to a single sub-instance, applications
6457
- * SHOULD consider the instance location to be deprecated if any occurrence
6458
- * specifies a `true` value.
6459
- *
6460
- * If `deprecated` has a value of boolean `true`, it indicates that
6461
- * applications SHOULD refrain from usage of the declared property. It MAY
6462
- * mean the property is going to be removed in the future.
6463
- *
6464
- * A root schema containing `deprecated` with a value of `true`
6465
- * indicates that the entire resource being described MAY be removed in the
6466
- * future.
6467
- *
6468
- * The `deprecated` keyword applies to each instance location to which
6469
- * the schema object containing the keyword successfully applies. This can
6470
- * result in scenarios where every array item or object property is
6471
- * deprecated even though the containing array or object is not.
6472
- *
6473
- * Omitting this keyword has the same behavior as a value of `false`.
6906
+ /**
6907
+ * The value of this keyword MUST be a boolean. When multiple occurrences
6908
+ * of this keyword are applicable to a single sub-instance, applications
6909
+ * SHOULD consider the instance location to be deprecated if any occurrence
6910
+ * specifies a `true` value.
6911
+ *
6912
+ * If `deprecated` has a value of boolean `true`, it indicates that
6913
+ * applications SHOULD refrain from usage of the declared property. It MAY
6914
+ * mean the property is going to be removed in the future.
6915
+ *
6916
+ * A root schema containing `deprecated` with a value of `true`
6917
+ * indicates that the entire resource being described MAY be removed in the
6918
+ * future.
6919
+ *
6920
+ * The `deprecated` keyword applies to each instance location to which
6921
+ * the schema object containing the keyword successfully applies. This can
6922
+ * result in scenarios where every array item or object property is
6923
+ * deprecated even though the containing array or object is not.
6924
+ *
6925
+ * Omitting this keyword has the same behavior as a value of `false`.
6474
6926
  */
6475
6927
  deprecated?: boolean;
6476
- /**
6477
- * Can be used to decorate a user interface with explanation or information
6478
- * about the data produced.
6928
+ /**
6929
+ * Can be used to decorate a user interface with explanation or information
6930
+ * about the data produced.
6479
6931
  */
6480
6932
  description?: string;
6481
- /**
6482
- * This keyword's value MUST be a valid JSON Schema.
6483
- *
6484
- * When `if` is present, and the instance fails to validate against its
6485
- * subschema, then validation succeeds against this keyword if the instance
6486
- * successfully validates against this keyword's subschema.
6487
- *
6488
- * This keyword has no effect when `if` is absent, or when the instance
6489
- * successfully validates against its subschema. Implementations MUST NOT
6490
- * evaluate the instance against this keyword, for either validation or
6491
- * annotation collection purposes, in such cases.
6933
+ /**
6934
+ * This keyword's value MUST be a valid JSON Schema.
6935
+ *
6936
+ * When `if` is present, and the instance fails to validate against its
6937
+ * subschema, then validation succeeds against this keyword if the instance
6938
+ * successfully validates against this keyword's subschema.
6939
+ *
6940
+ * This keyword has no effect when `if` is absent, or when the instance
6941
+ * successfully validates against its subschema. Implementations MUST NOT
6942
+ * evaluate the instance against this keyword, for either validation or
6943
+ * annotation collection purposes, in such cases.
6492
6944
  */
6493
6945
  else?: JSONSchema<Value, SchemaType>;
6494
- /**
6495
- * The value of this keyword MUST be an array. This array SHOULD have at
6496
- * least one element. Elements in the array SHOULD be unique.
6497
- *
6498
- * An instance validates successfully against this keyword if its value is
6499
- * equal to one of the elements in this keyword's array value.
6500
- *
6501
- * Elements in the array might be of any type, including `null`.
6946
+ /**
6947
+ * The value of this keyword MUST be an array. This array SHOULD have at
6948
+ * least one element. Elements in the array SHOULD be unique.
6949
+ *
6950
+ * An instance validates successfully against this keyword if its value is
6951
+ * equal to one of the elements in this keyword's array value.
6952
+ *
6953
+ * Elements in the array might be of any type, including `null`.
6502
6954
  */
6503
6955
  enum?: MaybeReadonlyArray<Value>;
6504
- /**
6505
- * The value of this keyword MUST be an array. When multiple occurrences of
6506
- * this keyword are applicable to a single sub-instance, implementations
6507
- * MUST provide a flat array of all values rather than an array of arrays.
6508
- *
6509
- * This keyword can be used to provide sample JSON values associated with a
6510
- * particular schema, for the purpose of illustrating usage. It is
6511
- * RECOMMENDED that these values be valid against the associated schema.
6512
- *
6513
- * Implementations MAY use the value(s) of `default`, if present, as an
6514
- * additional example. If `examples` is absent, `default` MAY still be
6515
- * used in this manner.
6956
+ /**
6957
+ * The value of this keyword MUST be an array. When multiple occurrences of
6958
+ * this keyword are applicable to a single sub-instance, implementations
6959
+ * MUST provide a flat array of all values rather than an array of arrays.
6960
+ *
6961
+ * This keyword can be used to provide sample JSON values associated with a
6962
+ * particular schema, for the purpose of illustrating usage. It is
6963
+ * RECOMMENDED that these values be valid against the associated schema.
6964
+ *
6965
+ * Implementations MAY use the value(s) of `default`, if present, as an
6966
+ * additional example. If `examples` is absent, `default` MAY still be
6967
+ * used in this manner.
6516
6968
  */
6517
6969
  examples?: MaybeReadonlyArray<Value>;
6518
- /**
6519
- * The value of `exclusiveMaximum` MUST be a number, representing an
6520
- * exclusive upper limit for a numeric instance.
6521
- *
6522
- * If the instance is a number, then the instance is valid only if it has a
6523
- * value strictly less than (not equal to) `exclusiveMaximum`.
6970
+ /**
6971
+ * The value of `exclusiveMaximum` MUST be a number, representing an
6972
+ * exclusive upper limit for a numeric instance.
6973
+ *
6974
+ * If the instance is a number, then the instance is valid only if it has a
6975
+ * value strictly less than (not equal to) `exclusiveMaximum`.
6524
6976
  */
6525
6977
  exclusiveMaximum?: number;
6526
- /**
6527
- * The value of `exclusiveMinimum` MUST be a number, representing an
6528
- * exclusive lower limit for a numeric instance.
6529
- *
6530
- * If the instance is a number, then the instance is valid only if it has a
6531
- * value strictly greater than (not equal to) `exclusiveMinimum`.
6978
+ /**
6979
+ * The value of `exclusiveMinimum` MUST be a number, representing an
6980
+ * exclusive lower limit for a numeric instance.
6981
+ *
6982
+ * If the instance is a number, then the instance is valid only if it has a
6983
+ * value strictly greater than (not equal to) `exclusiveMinimum`.
6532
6984
  */
6533
6985
  exclusiveMinimum?: number;
6534
- /**
6535
- * Implementations MAY treat `format` as an assertion in addition to an
6536
- * annotation, and attempt to validate the value's conformance to the
6537
- * specified semantics.
6538
- *
6539
- * The value of this keyword is called a format attribute. It MUST be a
6540
- * string. A format attribute can generally only validate a given set
6541
- * of instance types. If the type of the instance to validate is not in
6542
- * this set, validation for this format attribute and instance SHOULD
6543
- * succeed. Format attributes are most often applied to strings, but can
6544
- * be specified to apply to any type.
6545
- *
6546
- * Implementations MAY support custom format attributes. Save for agreement
6547
- * between parties, schema authors SHALL NOT expect a peer implementation
6548
- * to support such custom format attributes. An implementation MUST NOT
6549
- * fail validation or cease processing due to an unknown format attribute.
6550
- * When treating `format` as an annotation, implementations SHOULD
6551
- * collect both known and unknown format attribute values.
6986
+ /**
6987
+ * Implementations MAY treat `format` as an assertion in addition to an
6988
+ * annotation, and attempt to validate the value's conformance to the
6989
+ * specified semantics.
6990
+ *
6991
+ * The value of this keyword is called a format attribute. It MUST be a
6992
+ * string. A format attribute can generally only validate a given set
6993
+ * of instance types. If the type of the instance to validate is not in
6994
+ * this set, validation for this format attribute and instance SHOULD
6995
+ * succeed. Format attributes are most often applied to strings, but can
6996
+ * be specified to apply to any type.
6997
+ *
6998
+ * Implementations MAY support custom format attributes. Save for agreement
6999
+ * between parties, schema authors SHALL NOT expect a peer implementation
7000
+ * to support such custom format attributes. An implementation MUST NOT
7001
+ * fail validation or cease processing due to an unknown format attribute.
7002
+ * When treating `format` as an annotation, implementations SHOULD
7003
+ * collect both known and unknown format attribute values.
6552
7004
  */
6553
7005
  format?: string;
6554
- /**
6555
- * This keyword's value MUST be a valid JSON Schema.
6556
- *
6557
- * This validation outcome of this keyword's subschema has no direct effect
6558
- * on the overall validation result. Rather, it controls which of the
6559
- * `then` or `else` keywords are evaluated.
6560
- *
6561
- * Instances that successfully validate against this keyword's subschema
6562
- * MUST also be valid against the subschema value of the `then` keyword,
6563
- * if present.
6564
- *
6565
- * Instances that fail to validate against this keyword's subschema MUST
6566
- * also be valid against the subschema value of the `else` keyword, if
6567
- * present.
6568
- *
6569
- * If annotations are being collected, they are collected
6570
- * from this keyword's subschema in the usual way, including when the
6571
- * keyword is present without either `then` or `else`.
7006
+ /**
7007
+ * This keyword's value MUST be a valid JSON Schema.
7008
+ *
7009
+ * This validation outcome of this keyword's subschema has no direct effect
7010
+ * on the overall validation result. Rather, it controls which of the
7011
+ * `then` or `else` keywords are evaluated.
7012
+ *
7013
+ * Instances that successfully validate against this keyword's subschema
7014
+ * MUST also be valid against the subschema value of the `then` keyword,
7015
+ * if present.
7016
+ *
7017
+ * Instances that fail to validate against this keyword's subschema MUST
7018
+ * also be valid against the subschema value of the `else` keyword, if
7019
+ * present.
7020
+ *
7021
+ * If annotations are being collected, they are collected
7022
+ * from this keyword's subschema in the usual way, including when the
7023
+ * keyword is present without either `then` or `else`.
6572
7024
  */
6573
7025
  if?: JSONSchema<Value, SchemaType>;
6574
- /**
6575
- * The value of `items` MUST be a valid JSON Schema.
6576
- *
6577
- * This keyword applies its subschema to all instance elements at indexes
6578
- * greater than the length of the `prefixItems` array in the same schema
6579
- * object, as reported by the annotation result of that `prefixItems`
6580
- * keyword. If no such annotation result exists, `items` applies its
6581
- * subschema to all instance array elements.
6582
- *
6583
- * Note that the behavior of `items` without `prefixItems` is identical
6584
- * to that of the schema form of `items` in prior drafts.
6585
- *
6586
- * When `prefixItems` is present, the behavior of `items` is identical
6587
- * to the former `additionalItems` keyword.
6588
- *
6589
- * If the `items` subschema is applied to any positions within the
6590
- * instance array, it produces an annotation result of boolean `true`,
6591
- * indicating that all remaining array elements have been evaluated against
6592
- * this keyword's subschema.
6593
- *
6594
- * Omitting this keyword has the same assertion behavior as an empty
6595
- * schema.
6596
- *
6597
- * Implementations MAY choose to implement or optimize this keyword
6598
- * in another way that produces the same effect, such as by directly
6599
- * checking for the presence and size of a `prefixItems` array.
7026
+ /**
7027
+ * The value of `items` MUST be a valid JSON Schema.
7028
+ *
7029
+ * This keyword applies its subschema to all instance elements at indexes
7030
+ * greater than the length of the `prefixItems` array in the same schema
7031
+ * object, as reported by the annotation result of that `prefixItems`
7032
+ * keyword. If no such annotation result exists, `items` applies its
7033
+ * subschema to all instance array elements.
7034
+ *
7035
+ * Note that the behavior of `items` without `prefixItems` is identical
7036
+ * to that of the schema form of `items` in prior drafts.
7037
+ *
7038
+ * When `prefixItems` is present, the behavior of `items` is identical
7039
+ * to the former `additionalItems` keyword.
7040
+ *
7041
+ * If the `items` subschema is applied to any positions within the
7042
+ * instance array, it produces an annotation result of boolean `true`,
7043
+ * indicating that all remaining array elements have been evaluated against
7044
+ * this keyword's subschema.
7045
+ *
7046
+ * Omitting this keyword has the same assertion behavior as an empty
7047
+ * schema.
7048
+ *
7049
+ * Implementations MAY choose to implement or optimize this keyword
7050
+ * in another way that produces the same effect, such as by directly
7051
+ * checking for the presence and size of a `prefixItems` array.
6600
7052
  */
6601
7053
  items?: JSONSchema;
6602
- /**
6603
- * The value of this keyword MUST be a non-negative integer.
6604
- *
6605
- * If `contains` is not present within the same schema object, then this
6606
- * keyword has no effect.
6607
- *
6608
- * An instance array is valid against `maxContains` in two ways,
6609
- * depending on the form of the annotation result of an adjacent
6610
- * `contains` keyword. The first way is if the annotation result is an
6611
- * array and the length of that array is less than or equal to the
6612
- * `maxContains` value. The second way is if the annotation result is a
6613
- * boolean `true` and the instance array length is less than or equal to
6614
- * the `maxContains` value.
7054
+ /**
7055
+ * The value of this keyword MUST be a non-negative integer.
7056
+ *
7057
+ * If `contains` is not present within the same schema object, then this
7058
+ * keyword has no effect.
7059
+ *
7060
+ * An instance array is valid against `maxContains` in two ways,
7061
+ * depending on the form of the annotation result of an adjacent
7062
+ * `contains` keyword. The first way is if the annotation result is an
7063
+ * array and the length of that array is less than or equal to the
7064
+ * `maxContains` value. The second way is if the annotation result is a
7065
+ * boolean `true` and the instance array length is less than or equal to
7066
+ * the `maxContains` value.
6615
7067
  */
6616
7068
  maxContains?: number;
6617
- /**
6618
- * The value of `maximum` MUST be a number, representing an inclusive
6619
- * upper limit for a numeric instance.
6620
- *
6621
- * If the instance is a number, then this keyword validates only if the
6622
- * instance is less than or exactly equal to `maximum`.
7069
+ /**
7070
+ * The value of `maximum` MUST be a number, representing an inclusive
7071
+ * upper limit for a numeric instance.
7072
+ *
7073
+ * If the instance is a number, then this keyword validates only if the
7074
+ * instance is less than or exactly equal to `maximum`.
6623
7075
  */
6624
7076
  maximum?: number;
6625
- /**
6626
- * The value of this keyword MUST be a non-negative integer.
6627
- *
6628
- * An array instance is valid against `maxItems` if its size is less
6629
- * than, or equal to, the value of this keyword.
6630
- *
6631
- * @minimum 0
7077
+ /**
7078
+ * The value of this keyword MUST be a non-negative integer.
7079
+ *
7080
+ * An array instance is valid against `maxItems` if its size is less
7081
+ * than, or equal to, the value of this keyword.
7082
+ *
7083
+ * @minimum 0
6632
7084
  */
6633
7085
  maxItems?: number;
6634
- /**
6635
- * The value of this keyword MUST be a non-negative integer.
6636
- *
6637
- * A string instance is valid against this keyword if its length is less
6638
- * than, or equal to, the value of this keyword.
6639
- *
6640
- * The length of a string instance is defined as the number of its
6641
- * characters as defined by [RFC 8259][RFC8259].
6642
- *
6643
- * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
6644
- *
6645
- * @minimum 0
7086
+ /**
7087
+ * The value of this keyword MUST be a non-negative integer.
7088
+ *
7089
+ * A string instance is valid against this keyword if its length is less
7090
+ * than, or equal to, the value of this keyword.
7091
+ *
7092
+ * The length of a string instance is defined as the number of its
7093
+ * characters as defined by [RFC 8259][RFC8259].
7094
+ *
7095
+ * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
7096
+ *
7097
+ * @minimum 0
6646
7098
  */
6647
7099
  maxLength?: number;
6648
- /**
6649
- * The value of this keyword MUST be a non-negative integer.
6650
- *
6651
- * An object instance is valid against `maxProperties` if its number of
6652
- * `properties` is less than, or equal to, the value of this keyword.
6653
- *
6654
- * @minimum 0
7100
+ /**
7101
+ * The value of this keyword MUST be a non-negative integer.
7102
+ *
7103
+ * An object instance is valid against `maxProperties` if its number of
7104
+ * `properties` is less than, or equal to, the value of this keyword.
7105
+ *
7106
+ * @minimum 0
6655
7107
  */
6656
7108
  maxProperties?: number;
6657
- /**
6658
- * The value of this keyword MUST be a non-negative integer.
6659
- *
6660
- * If `contains` is not present within the same schema object, then this
6661
- * keyword has no effect.
6662
- *
6663
- * An instance array is valid against `minContains` in two ways,
6664
- * depending on the form of the annotation result of an adjacent
6665
- * `contains` keyword. The first way is if the annotation result is an
6666
- * array and the length of that array is greater than or equal to the
6667
- * `minContains` value. The second way is if the annotation result is a
6668
- * boolean `true` and the instance array length is greater than or equal
6669
- * to the `minContains` value.
6670
- *
6671
- * A value of `0` is allowed, but is only useful for setting a range
6672
- * of occurrences from `0` to the value of `maxContains`. A value of
6673
- * `0` with no `maxContains` causes `contains` to always pass
6674
- * validation.
6675
- *
6676
- * Omitting this keyword has the same behavior as a value of `1`.
6677
- *
6678
- * @default 1
7109
+ /**
7110
+ * The value of this keyword MUST be a non-negative integer.
7111
+ *
7112
+ * If `contains` is not present within the same schema object, then this
7113
+ * keyword has no effect.
7114
+ *
7115
+ * An instance array is valid against `minContains` in two ways,
7116
+ * depending on the form of the annotation result of an adjacent
7117
+ * `contains` keyword. The first way is if the annotation result is an
7118
+ * array and the length of that array is greater than or equal to the
7119
+ * `minContains` value. The second way is if the annotation result is a
7120
+ * boolean `true` and the instance array length is greater than or equal
7121
+ * to the `minContains` value.
7122
+ *
7123
+ * A value of `0` is allowed, but is only useful for setting a range
7124
+ * of occurrences from `0` to the value of `maxContains`. A value of
7125
+ * `0` with no `maxContains` causes `contains` to always pass
7126
+ * validation.
7127
+ *
7128
+ * Omitting this keyword has the same behavior as a value of `1`.
7129
+ *
7130
+ * @default 1
6679
7131
  */
6680
7132
  minContains?: number;
6681
- /**
6682
- * The value of `minimum` MUST be a number, representing an inclusive
6683
- * lower limit for a numeric instance.
6684
- *
6685
- * If the instance is a number, then this keyword validates only if the
6686
- * instance is greater than or exactly equal to `minimum`.
7133
+ /**
7134
+ * The value of `minimum` MUST be a number, representing an inclusive
7135
+ * lower limit for a numeric instance.
7136
+ *
7137
+ * If the instance is a number, then this keyword validates only if the
7138
+ * instance is greater than or exactly equal to `minimum`.
6687
7139
  */
6688
7140
  minimum?: number;
6689
- /**
6690
- * The value of this keyword MUST be a non-negative integer.
6691
- *
6692
- * An array instance is valid against `minItems` if its size is greater
6693
- * than, or equal to, the value of this keyword.
6694
- *
6695
- * Omitting this keyword has the same behavior as a value of `0`.
6696
- *
6697
- * @default 0
6698
- * @minimum 0
7141
+ /**
7142
+ * The value of this keyword MUST be a non-negative integer.
7143
+ *
7144
+ * An array instance is valid against `minItems` if its size is greater
7145
+ * than, or equal to, the value of this keyword.
7146
+ *
7147
+ * Omitting this keyword has the same behavior as a value of `0`.
7148
+ *
7149
+ * @default 0
7150
+ * @minimum 0
6699
7151
  */
6700
7152
  minItems?: number;
6701
- /**
6702
- * The value of this keyword MUST be a non-negative integer.
6703
- *
6704
- * A string instance is valid against this keyword if its length is greater
6705
- * than, or equal to, the value of this keyword.
6706
- *
6707
- * The length of a string instance is defined as the number of its
6708
- * characters as defined by [RFC 8259][RFC8259].
6709
- *
6710
- * Omitting this keyword has the same behavior as a value of `0`.
6711
- *
6712
- * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
6713
- *
6714
- * @default 0
6715
- * @minimum 0
7153
+ /**
7154
+ * The value of this keyword MUST be a non-negative integer.
7155
+ *
7156
+ * A string instance is valid against this keyword if its length is greater
7157
+ * than, or equal to, the value of this keyword.
7158
+ *
7159
+ * The length of a string instance is defined as the number of its
7160
+ * characters as defined by [RFC 8259][RFC8259].
7161
+ *
7162
+ * Omitting this keyword has the same behavior as a value of `0`.
7163
+ *
7164
+ * [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
7165
+ *
7166
+ * @default 0
7167
+ * @minimum 0
6716
7168
  */
6717
7169
  minLength?: number;
6718
- /**
6719
- * The value of this keyword MUST be a non-negative integer.
6720
- *
6721
- * An object instance is valid against `minProperties` if its number of
6722
- * `properties` is greater than, or equal to, the value of this keyword.
6723
- *
6724
- * Omitting this keyword has the same behavior as a value of `0`.
6725
- *
6726
- * @default 0
6727
- * @minimum 0
7170
+ /**
7171
+ * The value of this keyword MUST be a non-negative integer.
7172
+ *
7173
+ * An object instance is valid against `minProperties` if its number of
7174
+ * `properties` is greater than, or equal to, the value of this keyword.
7175
+ *
7176
+ * Omitting this keyword has the same behavior as a value of `0`.
7177
+ *
7178
+ * @default 0
7179
+ * @minimum 0
6728
7180
  */
6729
7181
  minProperties?: number;
6730
- /**
6731
- * The value of `multipleOf` MUST be a number, strictly greater than
6732
- * `0`.
6733
- *
6734
- * A numeric instance is valid only if division by this keyword's value
6735
- * results in an integer.
6736
- *
6737
- * @exclusiveMinimum 0
7182
+ /**
7183
+ * The value of `multipleOf` MUST be a number, strictly greater than
7184
+ * `0`.
7185
+ *
7186
+ * A numeric instance is valid only if division by this keyword's value
7187
+ * results in an integer.
7188
+ *
7189
+ * @exclusiveMinimum 0
6738
7190
  */
6739
7191
  multipleOf?: number;
6740
- /**
6741
- * This keyword's value MUST be a valid JSON Schema.
6742
- *
6743
- * An instance is valid against this keyword if it fails to validate
6744
- * successfully against the schema defined by this keyword.
7192
+ /**
7193
+ * This keyword's value MUST be a valid JSON Schema.
7194
+ *
7195
+ * An instance is valid against this keyword if it fails to validate
7196
+ * successfully against the schema defined by this keyword.
6745
7197
  */
6746
7198
  not?: JSONSchema<Value, SchemaType>;
6747
- /**
6748
- * This keyword's value MUST be a non-empty array. Each item of the array
6749
- * MUST be a valid JSON Schema.
6750
- *
6751
- * An instance validates successfully against this keyword if it validates
6752
- * successfully against exactly one schema defined by this keyword's value.
7199
+ /**
7200
+ * This keyword's value MUST be a non-empty array. Each item of the array
7201
+ * MUST be a valid JSON Schema.
7202
+ *
7203
+ * An instance validates successfully against this keyword if it validates
7204
+ * successfully against exactly one schema defined by this keyword's value.
6753
7205
  */
6754
7206
  oneOf?: MaybeReadonlyArray<JSONSchema<Value, SchemaType>>;
6755
- /**
6756
- * The value of this keyword MUST be a string. This string SHOULD be a
6757
- * valid regular expression, according to the [ECMA-262][ecma262] regular
6758
- * expression dialect.
6759
- *
6760
- * A string instance is considered valid if the regular expression matches
6761
- * the instance successfully. Recall: regular expressions are not
6762
- * implicitly anchored.
6763
- *
6764
- * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
6765
- *
6766
- * @format "regex"
7207
+ /**
7208
+ * The value of this keyword MUST be a string. This string SHOULD be a
7209
+ * valid regular expression, according to the [ECMA-262][ecma262] regular
7210
+ * expression dialect.
7211
+ *
7212
+ * A string instance is considered valid if the regular expression matches
7213
+ * the instance successfully. Recall: regular expressions are not
7214
+ * implicitly anchored.
7215
+ *
7216
+ * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
7217
+ *
7218
+ * @format "regex"
6767
7219
  */
6768
7220
  pattern?: string;
6769
- /**
6770
- * The value of `patternProperties` MUST be an object. Each property name
6771
- * of this object SHOULD be a valid regular expression, according to the
6772
- * [ECMA-262][ecma262] regular expression dialect. Each property value of
6773
- * this object MUST be a valid JSON Schema.
6774
- *
6775
- * Validation succeeds if, for each instance name that matches any regular
6776
- * expressions that appear as a property name in this keyword's value,
6777
- * the child instance for that name successfully validates against each
6778
- * schema that corresponds to a matching regular expression.
6779
- *
6780
- * The annotation result of this keyword is the set of instance property
6781
- * names matched by this keyword. Omitting this keyword has the same
6782
- * assertion behavior as an empty object.
6783
- *
6784
- * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
7221
+ /**
7222
+ * The value of `patternProperties` MUST be an object. Each property name
7223
+ * of this object SHOULD be a valid regular expression, according to the
7224
+ * [ECMA-262][ecma262] regular expression dialect. Each property value of
7225
+ * this object MUST be a valid JSON Schema.
7226
+ *
7227
+ * Validation succeeds if, for each instance name that matches any regular
7228
+ * expressions that appear as a property name in this keyword's value,
7229
+ * the child instance for that name successfully validates against each
7230
+ * schema that corresponds to a matching regular expression.
7231
+ *
7232
+ * The annotation result of this keyword is the set of instance property
7233
+ * names matched by this keyword. Omitting this keyword has the same
7234
+ * assertion behavior as an empty object.
7235
+ *
7236
+ * [ecma262]: https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
6785
7237
  */
6786
7238
  patternProperties?: Record<string, JSONSchema>;
6787
- /**
6788
- * The value of `prefixItems` MUST be a non-empty array of valid JSON
6789
- * Schemas.
6790
- *
6791
- * Validation succeeds if each element of the instance validates against
6792
- * the schema at the same position, if any. This keyword does not
6793
- * constrain the length of the array. If the array is longer than this
6794
- * keyword's value, this keyword validates only the prefix of matching
6795
- * length.
6796
- *
6797
- * This keyword produces an annotation value which is the largest index to
6798
- * which this keyword applied a subschema. The value MAY be a boolean
6799
- * `true` if a subschema was applied to every index of the instance, such
6800
- * as is produced by the `items` keyword.
6801
- * This annotation affects the behavior of `items` and
6802
- * `unevaluatedItems`.
6803
- *
6804
- * Omitting this keyword has the same assertion behavior as an empty array.
7239
+ /**
7240
+ * The value of `prefixItems` MUST be a non-empty array of valid JSON
7241
+ * Schemas.
7242
+ *
7243
+ * Validation succeeds if each element of the instance validates against
7244
+ * the schema at the same position, if any. This keyword does not
7245
+ * constrain the length of the array. If the array is longer than this
7246
+ * keyword's value, this keyword validates only the prefix of matching
7247
+ * length.
7248
+ *
7249
+ * This keyword produces an annotation value which is the largest index to
7250
+ * which this keyword applied a subschema. The value MAY be a boolean
7251
+ * `true` if a subschema was applied to every index of the instance, such
7252
+ * as is produced by the `items` keyword.
7253
+ * This annotation affects the behavior of `items` and
7254
+ * `unevaluatedItems`.
7255
+ *
7256
+ * Omitting this keyword has the same assertion behavior as an empty array.
6805
7257
  */
6806
7258
  prefixItems?: MaybeReadonlyArray<JSONSchema> | JSONSchema;
6807
- /**
6808
- * The value of `properties` MUST be an object. Each value of this object
6809
- * MUST be a valid JSON Schema.
6810
- *
6811
- * Validation succeeds if, for each name that appears in both the instance
6812
- * and as a name within this keyword's value, the child instance for that
6813
- * name successfully validates against the corresponding schema.
6814
- *
6815
- * The annotation result of this keyword is the set of instance property
6816
- * names matched by this keyword.
6817
- *
6818
- * Omitting this keyword has the same assertion behavior as an empty
6819
- * object.
7259
+ /**
7260
+ * The value of `properties` MUST be an object. Each value of this object
7261
+ * MUST be a valid JSON Schema.
7262
+ *
7263
+ * Validation succeeds if, for each name that appears in both the instance
7264
+ * and as a name within this keyword's value, the child instance for that
7265
+ * name successfully validates against the corresponding schema.
7266
+ *
7267
+ * The annotation result of this keyword is the set of instance property
7268
+ * names matched by this keyword.
7269
+ *
7270
+ * Omitting this keyword has the same assertion behavior as an empty
7271
+ * object.
6820
7272
  */
6821
7273
  properties?: Record<string, JSONSchema>;
6822
- /**
6823
- * The value of `propertyNames` MUST be a valid JSON Schema.
6824
- *
6825
- * If the instance is an object, this keyword validates if every property
6826
- * name in the instance validates against the provided schema.
6827
- * Note the property name that the schema is testing will always be a
6828
- * string.
6829
- *
6830
- * Omitting this keyword has the same behavior as an empty schema.
7274
+ /**
7275
+ * The value of `propertyNames` MUST be a valid JSON Schema.
7276
+ *
7277
+ * If the instance is an object, this keyword validates if every property
7278
+ * name in the instance validates against the provided schema.
7279
+ * Note the property name that the schema is testing will always be a
7280
+ * string.
7281
+ *
7282
+ * Omitting this keyword has the same behavior as an empty schema.
6831
7283
  */
6832
7284
  propertyNames?: JSONSchema;
6833
- /**
6834
- * The value of this keyword MUST be a boolean. When multiple occurrences
6835
- * of this keyword are applicable to a single sub-instance, the resulting
6836
- * value MUST be `true` if any occurrence specifies a `true` value, and
6837
- * MUST be `false` otherwise.
6838
- *
6839
- * If `readOnly` has a value of boolean `true`, it indicates that the
6840
- * value of the instance is managed exclusively by the owning authority,
6841
- * and attempts by an application to modify the value of this property are
6842
- * expected to be ignored or rejected by that owning authority.
6843
- *
6844
- * An instance document that is marked as `readOnly` for the entire
6845
- * document MAY be ignored if sent to the owning authority, or MAY result
6846
- * in an error, at the authority's discretion.
6847
- *
6848
- * For example, `readOnly` would be used to mark a database-generated
6849
- * serial number as read-only.
6850
- *
6851
- * This keyword can be used to assist in user interface instance
6852
- * generation.
6853
- *
6854
- * @default false
7285
+ /**
7286
+ * The value of this keyword MUST be a boolean. When multiple occurrences
7287
+ * of this keyword are applicable to a single sub-instance, the resulting
7288
+ * value MUST be `true` if any occurrence specifies a `true` value, and
7289
+ * MUST be `false` otherwise.
7290
+ *
7291
+ * If `readOnly` has a value of boolean `true`, it indicates that the
7292
+ * value of the instance is managed exclusively by the owning authority,
7293
+ * and attempts by an application to modify the value of this property are
7294
+ * expected to be ignored or rejected by that owning authority.
7295
+ *
7296
+ * An instance document that is marked as `readOnly` for the entire
7297
+ * document MAY be ignored if sent to the owning authority, or MAY result
7298
+ * in an error, at the authority's discretion.
7299
+ *
7300
+ * For example, `readOnly` would be used to mark a database-generated
7301
+ * serial number as read-only.
7302
+ *
7303
+ * This keyword can be used to assist in user interface instance
7304
+ * generation.
7305
+ *
7306
+ * @default false
6855
7307
  */
6856
7308
  readOnly?: boolean;
6857
- /**
6858
- * The value of this keyword MUST be an array. Elements of this array, if
6859
- * any, MUST be strings, and MUST be unique.
6860
- *
6861
- * An object instance is valid against this keyword if every item in the
6862
- * array is the name of a property in the instance.
6863
- *
6864
- * Omitting this keyword has the same behavior as an empty array.
7309
+ /**
7310
+ * The value of this keyword MUST be an array. Elements of this array, if
7311
+ * any, MUST be strings, and MUST be unique.
7312
+ *
7313
+ * An object instance is valid against this keyword if every item in the
7314
+ * array is the name of a property in the instance.
7315
+ *
7316
+ * Omitting this keyword has the same behavior as an empty array.
6865
7317
  */
6866
7318
  required?: MaybeReadonlyArray<string>;
6867
- /**
6868
- * This keyword's value MUST be a valid JSON Schema.
6869
- *
6870
- * When `if` is present, and the instance successfully validates against
6871
- * its subschema, then validation succeeds against this keyword if the
6872
- * instance also successfully validates against this keyword's subschema.
6873
- *
6874
- * This keyword has no effect when `if` is absent, or when the instance
6875
- * fails to validate against its subschema. Implementations MUST NOT
6876
- * evaluate the instance against this keyword, for either validation or
6877
- * annotation collection purposes, in such cases.
7319
+ /**
7320
+ * This keyword's value MUST be a valid JSON Schema.
7321
+ *
7322
+ * When `if` is present, and the instance successfully validates against
7323
+ * its subschema, then validation succeeds against this keyword if the
7324
+ * instance also successfully validates against this keyword's subschema.
7325
+ *
7326
+ * This keyword has no effect when `if` is absent, or when the instance
7327
+ * fails to validate against its subschema. Implementations MUST NOT
7328
+ * evaluate the instance against this keyword, for either validation or
7329
+ * annotation collection purposes, in such cases.
6878
7330
  */
6879
7331
  then?: JSONSchema<Value, SchemaType>;
6880
- /**
6881
- * Can be used to decorate a user interface with a short label about the
6882
- * data produced.
7332
+ /**
7333
+ * Can be used to decorate a user interface with a short label about the
7334
+ * data produced.
6883
7335
  */
6884
7336
  title?: string;
6885
- /**
6886
- * The value of this keyword MUST be either a string or an array. If it is
6887
- * an array, elements of the array MUST be strings and MUST be unique.
6888
- *
6889
- * String values MUST be one of the six primitive types (`"null"`,
6890
- * `"boolean"`, `"object"`, `"array"`, `"number"`, or
6891
- * `"string"`), or `"integer"` which matches any number with a zero
6892
- * fractional part.
6893
- *
6894
- * An instance validates if and only if the instance is in any of the sets
6895
- * listed for this keyword.
7337
+ /**
7338
+ * The value of this keyword MUST be either a string or an array. If it is
7339
+ * an array, elements of the array MUST be strings and MUST be unique.
7340
+ *
7341
+ * String values MUST be one of the six primitive types (`"null"`,
7342
+ * `"boolean"`, `"object"`, `"array"`, `"number"`, or
7343
+ * `"string"`), or `"integer"` which matches any number with a zero
7344
+ * fractional part.
7345
+ *
7346
+ * An instance validates if and only if the instance is in any of the sets
7347
+ * listed for this keyword.
6896
7348
  */
6897
7349
  type?: SchemaType;
6898
- /**
6899
- * The value of `unevaluatedItems` MUST be a valid JSON Schema.
6900
- *
6901
- * The behavior of this keyword depends on the annotation results of
6902
- * adjacent keywords that apply to the instance location being validated.
6903
- * Specifically, the annotations from `prefixItems`, `items`, and
6904
- * `contains`, which can come from those keywords when they are adjacent
6905
- * to the `unevaluatedItems` keyword. Those three annotations, as well as
6906
- * `unevaluatedItems`, can also result from any and all adjacent
6907
- * [in-place applicator][in-place-applicator] keywords.
6908
- *
6909
- * If no relevant annotations are present, the `unevaluatedItems`
6910
- * subschema MUST be applied to all locations in the array.
6911
- * If a boolean `true` value is present from any of the relevant
6912
- * annotations, `unevaluatedItems` MUST be ignored. Otherwise, the
6913
- * subschema MUST be applied to any index greater than the largest
6914
- * annotation value for `prefixItems`, which does not appear in any
6915
- * annotation value for `contains`.
6916
- *
6917
- * This means that `prefixItems`, `items`, `contains`, and all
6918
- * in-place applicators MUST be evaluated before this keyword can be
6919
- * evaluated. Authors of extension keywords MUST NOT define an in-place
6920
- * applicator that would need to be evaluated after this keyword.
6921
- *
6922
- * If the `unevaluatedItems` subschema is applied to any positions within
6923
- * the instance array, it produces an annotation result of boolean
6924
- * `true`, analogous to the behavior of `items`.
6925
- *
6926
- * Omitting this keyword has the same assertion behavior as an empty
6927
- * schema.
6928
- *
6929
- * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
7350
+ /**
7351
+ * The value of `unevaluatedItems` MUST be a valid JSON Schema.
7352
+ *
7353
+ * The behavior of this keyword depends on the annotation results of
7354
+ * adjacent keywords that apply to the instance location being validated.
7355
+ * Specifically, the annotations from `prefixItems`, `items`, and
7356
+ * `contains`, which can come from those keywords when they are adjacent
7357
+ * to the `unevaluatedItems` keyword. Those three annotations, as well as
7358
+ * `unevaluatedItems`, can also result from any and all adjacent
7359
+ * [in-place applicator][in-place-applicator] keywords.
7360
+ *
7361
+ * If no relevant annotations are present, the `unevaluatedItems`
7362
+ * subschema MUST be applied to all locations in the array.
7363
+ * If a boolean `true` value is present from any of the relevant
7364
+ * annotations, `unevaluatedItems` MUST be ignored. Otherwise, the
7365
+ * subschema MUST be applied to any index greater than the largest
7366
+ * annotation value for `prefixItems`, which does not appear in any
7367
+ * annotation value for `contains`.
7368
+ *
7369
+ * This means that `prefixItems`, `items`, `contains`, and all
7370
+ * in-place applicators MUST be evaluated before this keyword can be
7371
+ * evaluated. Authors of extension keywords MUST NOT define an in-place
7372
+ * applicator that would need to be evaluated after this keyword.
7373
+ *
7374
+ * If the `unevaluatedItems` subschema is applied to any positions within
7375
+ * the instance array, it produces an annotation result of boolean
7376
+ * `true`, analogous to the behavior of `items`.
7377
+ *
7378
+ * Omitting this keyword has the same assertion behavior as an empty
7379
+ * schema.
7380
+ *
7381
+ * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
6930
7382
  */
6931
7383
  unevaluatedItems?: JSONSchema;
6932
- /**
6933
- * The value of `unevaluatedProperties` MUST be a valid JSON Schema.
6934
- *
6935
- * The behavior of this keyword depends on the annotation results of
6936
- * adjacent keywords that apply to the instance location being validated.
6937
- * Specifically, the annotations from `properties`,
6938
- * `patternProperties`, and `additionalProperties`, which can come from
6939
- * those keywords when they are adjacent to the `unevaluatedProperties`
6940
- * keyword. Those three annotations, as well as `unevaluatedProperties`,
6941
- * can also result from any and all adjacent
6942
- * [in-place applicator][in-place-applicator] keywords.
6943
- *
6944
- * Validation with `unevaluatedProperties` applies only to the child
6945
- * values of instance names that do not appear in the `properties`,
6946
- * `patternProperties`, `additionalProperties`, or
6947
- * `unevaluatedProperties` annotation results that apply to the
6948
- * instance location being validated.
6949
- *
6950
- * For all such properties, validation succeeds if the child instance
6951
- * validates against the "unevaluatedProperties" schema.
6952
- *
6953
- * This means that `properties`, `patternProperties`,
6954
- * `additionalProperties`, and all in-place applicators MUST be evaluated
6955
- * before this keyword can be evaluated. Authors of extension keywords
6956
- * MUST NOT define an in-place applicator that would need to be evaluated
6957
- * after this keyword.
6958
- *
6959
- * The annotation result of this keyword is the set of instance property
6960
- * names validated by this keyword's subschema.
6961
- *
6962
- * Omitting this keyword has the same assertion behavior as an empty
6963
- * schema.
6964
- *
6965
- * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
7384
+ /**
7385
+ * The value of `unevaluatedProperties` MUST be a valid JSON Schema.
7386
+ *
7387
+ * The behavior of this keyword depends on the annotation results of
7388
+ * adjacent keywords that apply to the instance location being validated.
7389
+ * Specifically, the annotations from `properties`,
7390
+ * `patternProperties`, and `additionalProperties`, which can come from
7391
+ * those keywords when they are adjacent to the `unevaluatedProperties`
7392
+ * keyword. Those three annotations, as well as `unevaluatedProperties`,
7393
+ * can also result from any and all adjacent
7394
+ * [in-place applicator][in-place-applicator] keywords.
7395
+ *
7396
+ * Validation with `unevaluatedProperties` applies only to the child
7397
+ * values of instance names that do not appear in the `properties`,
7398
+ * `patternProperties`, `additionalProperties`, or
7399
+ * `unevaluatedProperties` annotation results that apply to the
7400
+ * instance location being validated.
7401
+ *
7402
+ * For all such properties, validation succeeds if the child instance
7403
+ * validates against the "unevaluatedProperties" schema.
7404
+ *
7405
+ * This means that `properties`, `patternProperties`,
7406
+ * `additionalProperties`, and all in-place applicators MUST be evaluated
7407
+ * before this keyword can be evaluated. Authors of extension keywords
7408
+ * MUST NOT define an in-place applicator that would need to be evaluated
7409
+ * after this keyword.
7410
+ *
7411
+ * The annotation result of this keyword is the set of instance property
7412
+ * names validated by this keyword's subschema.
7413
+ *
7414
+ * Omitting this keyword has the same assertion behavior as an empty
7415
+ * schema.
7416
+ *
7417
+ * [in-place-applicator]: https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
6966
7418
  */
6967
7419
  unevaluatedProperties?: JSONSchema;
6968
- /**
6969
- * The value of this keyword MUST be a boolean.
6970
- *
6971
- * If this keyword has boolean value `false`, the instance validates
6972
- * successfully. If it has boolean value `true`, the instance validates
6973
- * successfully if all of its elements are unique.
6974
- *
6975
- * Omitting this keyword has the same behavior as a value of `false`.
6976
- *
6977
- * @default false
7420
+ /**
7421
+ * The value of this keyword MUST be a boolean.
7422
+ *
7423
+ * If this keyword has boolean value `false`, the instance validates
7424
+ * successfully. If it has boolean value `true`, the instance validates
7425
+ * successfully if all of its elements are unique.
7426
+ *
7427
+ * Omitting this keyword has the same behavior as a value of `false`.
7428
+ *
7429
+ * @default false
6978
7430
  */
6979
7431
  uniqueItems?: boolean;
6980
- /**
6981
- * The value of this keyword MUST be a boolean. When multiple occurrences
6982
- * of this keyword is applicable to a single sub-instance, the resulting
6983
- * value MUST be `true` if any occurrence specifies a `true` value, and
6984
- * MUST be `false` otherwise.
6985
- *
6986
- * If `writeOnly` has a value of boolean `true`, it indicates that the
6987
- * value is never present when the instance is retrieved from the owning
6988
- * authority. It can be present when sent to the owning authority to update
6989
- * or create the document (or the resource it represents), but it will not
6990
- * be included in any updated or newly created version of the instance.
6991
- *
6992
- * An instance document that is marked as `writeOnly` for the entire
6993
- * document MAY be returned as a blank document of some sort, or MAY
6994
- * produce an error upon retrieval, or have the retrieval request ignored,
6995
- * at the authority's discretion.
6996
- *
6997
- * For example, `writeOnly` would be used to mark a password input field.
6998
- *
6999
- * These keywords can be used to assist in user interface instance
7000
- * generation. In particular, an application MAY choose to use a widget
7001
- * that hides input values as they are typed for write-only fields.
7002
- *
7003
- * @default false
7432
+ /**
7433
+ * The value of this keyword MUST be a boolean. When multiple occurrences
7434
+ * of this keyword is applicable to a single sub-instance, the resulting
7435
+ * value MUST be `true` if any occurrence specifies a `true` value, and
7436
+ * MUST be `false` otherwise.
7437
+ *
7438
+ * If `writeOnly` has a value of boolean `true`, it indicates that the
7439
+ * value is never present when the instance is retrieved from the owning
7440
+ * authority. It can be present when sent to the owning authority to update
7441
+ * or create the document (or the resource it represents), but it will not
7442
+ * be included in any updated or newly created version of the instance.
7443
+ *
7444
+ * An instance document that is marked as `writeOnly` for the entire
7445
+ * document MAY be returned as a blank document of some sort, or MAY
7446
+ * produce an error upon retrieval, or have the retrieval request ignored,
7447
+ * at the authority's discretion.
7448
+ *
7449
+ * For example, `writeOnly` would be used to mark a password input field.
7450
+ *
7451
+ * These keywords can be used to assist in user interface instance
7452
+ * generation. In particular, an application MAY choose to use a widget
7453
+ * that hides input values as they are typed for write-only fields.
7454
+ *
7455
+ * @default false
7004
7456
  */
7005
7457
  writeOnly?: boolean;
7006
7458
  };
7007
7459
  declare namespace JSONSchema {
7008
7460
  type TypeValue = ValueOf<TypeName> | TypeName | Array<ValueOf<TypeName> | TypeName> | ReadonlyArray<ValueOf<TypeName> | TypeName>;
7009
- /**
7010
- * JSON Schema interface
7461
+ /**
7462
+ * JSON Schema interface
7011
7463
  */
7012
7464
  type Interface<Value = any, SchemaType extends TypeValue = TypeValue> = Exclude<JSONSchema<Value, SchemaType>, boolean>;
7013
7465
  type Array<T = any> = Pick<Interface<T, "array">, KeywordByType.Any | KeywordByType.Array>;
@@ -7025,45 +7477,45 @@ declare namespace KeywordByType {
7025
7477
  type Object = "additionalProperties" | "dependencies" | "dependentRequired" | "dependentSchemas" | "maxProperties" | "minProperties" | "patternProperties" | "properties" | "propertyNames" | "required" | "unevaluatedProperties";
7026
7478
  type String = "contentEncoding" | "contentMediaType" | "contentSchema" | "maxLength" | "minLength" | "pattern";
7027
7479
  }
7028
- /**
7029
- * Enum consisting of simple type names for the `type` keyword
7480
+ /**
7481
+ * Enum consisting of simple type names for the `type` keyword
7030
7482
  */
7031
7483
  declare enum TypeName {
7032
- /**
7033
- * Value MUST be an array.
7484
+ /**
7485
+ * Value MUST be an array.
7034
7486
  */
7035
7487
  Array = "array",
7036
- /**
7037
- * Value MUST be a boolean.
7488
+ /**
7489
+ * Value MUST be a boolean.
7038
7490
  */
7039
7491
  Boolean = "boolean",
7040
- /**
7041
- * Value MUST be an integer, no floating point numbers are allowed. This is a
7042
- * subset of the number type.
7492
+ /**
7493
+ * Value MUST be an integer, no floating point numbers are allowed. This is a
7494
+ * subset of the number type.
7043
7495
  */
7044
7496
  Integer = "integer",
7045
- /**
7046
- * Value MUST be null. Note this is mainly for purpose of being able use union
7047
- * types to define nullability. If this type is not included in a union, null
7048
- * values are not allowed (the primitives listed above do not allow nulls on
7049
- * their own).
7497
+ /**
7498
+ * Value MUST be null. Note this is mainly for purpose of being able use union
7499
+ * types to define nullability. If this type is not included in a union, null
7500
+ * values are not allowed (the primitives listed above do not allow nulls on
7501
+ * their own).
7050
7502
  */
7051
7503
  Null = "null",
7052
- /**
7053
- * Value MUST be a number, floating point numbers are allowed.
7504
+ /**
7505
+ * Value MUST be a number, floating point numbers are allowed.
7054
7506
  */
7055
7507
  Number = "number",
7056
- /**
7057
- * Value MUST be an object.
7508
+ /**
7509
+ * Value MUST be an object.
7058
7510
  */
7059
7511
  Object = "object",
7060
- /**
7061
- * Value MUST be a string.
7512
+ /**
7513
+ * Value MUST be a string.
7062
7514
  */
7063
7515
  String = "string"
7064
7516
  }
7065
7517
  //#endregion
7066
- //#region ../../node_modules/.pnpm/@orpc+openapi@1.15.0_@opentelemetry+api@1.9.1_ws@8.21.3/node_modules/@orpc/openapi/dist/shared/openapi.BGy4N6eR.d.mts
7518
+ //#region ../../node_modules/.pnpm/@orpc+openapi@1.15.7_@opentelemetry+api@1.9.1_ws@8.22.0/node_modules/@orpc/openapi/dist/shared/openapi.BGy4N6eR.d.mts
7067
7519
  interface SchemaConverterComponent {
7068
7520
  allowedStrategies: readonly SchemaConvertOptions['strategy'][];
7069
7521
  schema: AnySchema;