@noodleseed/one 0.162.0 → 0.164.0

package/node_modules/@noodle-borg/wire-contracts/dist/application-settings.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+export declare const ApplicationSettingsProjectionSchema: z.ZodObject<{
+    revision: z.ZodString;
+    schemaDigest: z.ZodString;
+    releaseDigest: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        schemaVersion: z.ZodLiteral<1>;
+        valueSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        default: z.ZodOptional<z.ZodJSONSchema>;
+        portal: z.ZodObject<{
+            label: z.ZodString;
+            help: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        requiredFor: z.ZodArray<z.ZodString>;
+        schemaDigest: z.ZodString;
+    }, z.core.$strict>>;
+    values: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    provenance: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        app: "app";
+        default: "default";
+        operator: "operator";
+        organization: "organization";
+        unset: "unset";
+    }>>;
+    readiness: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        ready: z.ZodBoolean;
+        missing: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    canEdit: z.ZodBoolean;
+}, z.core.$strict>;
+export type ApplicationSettingsProjection = z.infer<typeof ApplicationSettingsProjectionSchema>;
+export declare const ApplicationSettingsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        schemaDigest: z.ZodString;
+        releaseDigest: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            schemaVersion: z.ZodLiteral<1>;
+            valueSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            default: z.ZodOptional<z.ZodJSONSchema>;
+            portal: z.ZodObject<{
+                label: z.ZodString;
+                help: z.ZodOptional<z.ZodString>;
+                group: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            requiredFor: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+        }, z.core.$strict>>;
+        values: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        provenance: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            app: "app";
+            default: "default";
+            operator: "operator";
+            organization: "organization";
+            unset: "unset";
+        }>>;
+        readiness: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            ready: z.ZodBoolean;
+            missing: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationSettingsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        schemaDigest: z.ZodString;
+        releaseDigest: z.ZodString;
+        values: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        provenance: z.ZodRecord<z.ZodString, z.ZodEnum<{
+            app: "app";
+            default: "default";
+            operator: "operator";
+            organization: "organization";
+            unset: "unset";
+        }>>;
+        canEdit: z.ZodBoolean;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            schemaVersion: z.ZodLiteral<1>;
+            valueSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            default: z.ZodOptional<z.ZodJSONSchema>;
+            requiredFor: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+            portal: z.ZodObject<{
+                label: z.ZodString;
+                help: z.ZodOptional<z.ZodString>;
+                group: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        readiness: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            ready: z.ZodBoolean;
+            missing: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationSettingsSaveRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodString;
+    schemaDigest: z.ZodString;
+    values: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    resetKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ApplicationSettingsSaveRequest = z.infer<typeof ApplicationSettingsSaveRequestSchema>;
+//# sourceMappingURL=application-settings.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-settings.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const key = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_]+$/)
+    .refine((value) => !['__proto__', 'prototype', 'constructor'].includes(value));
+const values = z.record(key, z.json());
+const declaration = z
+    .object({
+    name: key,
+    schemaVersion: z.literal(1),
+    valueSchema: z.record(z.string(), z.json()),
+    default: z.json().optional(),
+    portal: z
+        .object({
+        label: z.string().min(1).max(120),
+        help: z.string().max(1000).optional(),
+        group: z.string().max(120).optional(),
+    })
+        .strict(),
+    requiredFor: z.array(z.string().min(1).max(128)).max(128),
+    schemaDigest: z.string().regex(/^(?:sha256:)?[a-f0-9]{64}$/),
+})
+    .strict();
+export const ApplicationSettingsProjectionSchema = z
+    .object({
+    revision: digest,
+    schemaDigest: digest,
+    releaseDigest: z.string().min(1).max(128),
+    declarations: z.array(declaration).max(128),
+    values,
+    provenance: z.record(key, z.enum(['operator', 'default', 'organization', 'app', 'unset'])),
+    readiness: z
+        .array(z
+        .object({
+        tool: z.string().min(1).max(128),
+        ready: z.boolean(),
+        missing: z.array(key).max(128),
+    })
+        .strict())
+        .max(256),
+    canEdit: z.boolean(),
+})
+    .strict();
+export const ApplicationSettingsResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    data: ApplicationSettingsProjectionSchema,
+})
+    .strict();
+// Browser/CLI response readers tolerate additive server fields at every object boundary.
+export const ApplicationSettingsClientResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    data: ApplicationSettingsProjectionSchema.extend({
+        declarations: z.array(declaration.extend({ portal: declaration.shape.portal.strip() }).strip()),
+        readiness: z.array(ApplicationSettingsProjectionSchema.shape.readiness.element.strip()),
+    }).strip(),
+})
+    .strip();
+export const ApplicationSettingsSaveRequestSchema = z
+    .object({
+    expectedRevision: digest,
+    schemaDigest: digest,
+    values,
+    resetKeys: z.array(key).max(128).optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if (Object.keys(input.values).length > 128) {
+        context.addIssue({ code: 'custom', message: 'too many setting values', path: ['values'] });
+    }
+    if (new Set(input.resetKeys).size !== (input.resetKeys?.length ?? 0)) {
+        context.addIssue({ code: 'custom', message: 'duplicate reset key', path: ['resetKeys'] });
+    }
+    for (const name of input.resetKeys ?? []) {
+        if (Object.hasOwn(input.values, name)) {
+            context.addIssue({
+                code: 'custom',
+                message: 'cannot set and reset the same key',
+                path: ['values', name],
+            });
+        }
+    }
+});
+//# sourceMappingURL=application-settings.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/assistant.d.ts

@@ -205,8 +205,8 @@ export declare const assistantWireEventSchema: z.ZodUnion<readonly [z.ZodObject<
     event: z.ZodLiteral<string>;
     data: z.ZodObject<{
         result: z.ZodJSONSchema;
-        tool: z.ZodString;
         id: z.ZodString;
+        tool: z.ZodString;
         resourceUri: z.ZodString;
         title: z.ZodOptional<z.ZodString>;
         arguments: z.ZodOptional<z.ZodJSONSchema>;

package/node_modules/@noodle-borg/wire-contracts/dist/billing-catalog.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/** Protected release evidence. No customer-selected plan or allowance is accepted. */
+export declare const BillingCatalogActivationRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    candidate: z.ZodObject<{
+        releaseId: z.ZodString;
+        gitSha: z.ZodString;
+        manifestChecksum: z.ZodString;
+        imageDigest: z.ZodString;
+    }, z.core.$strict>;
+    rollback: z.ZodObject<{
+        releaseId: z.ZodString;
+        gitSha: z.ZodString;
+        manifestChecksum: z.ZodString;
+        imageDigest: z.ZodString;
+    }, z.core.$strict>;
+    checkedAt: z.ZodISODateTime;
+    revisions: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        gitSha: z.ZodString;
+        imageDigest: z.ZodString;
+    }, z.core.$strict>>;
+    retiredRevisions: z.ZodArray<z.ZodString>;
+    jobs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        activeExecutions: z.ZodLiteral<0>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BillingCatalogActivationRequest = z.infer<typeof BillingCatalogActivationRequestSchema>;
+export declare const BillingCatalogStatusResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        version: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        readerVersion: z.ZodLiteral<2>;
+        revision: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const BillingCatalogStatusClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        version: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        readerVersion: z.ZodLiteral<2>;
+        revision: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const BillingCatalogActivationResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        migrated: z.ZodNumber;
+        revision: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const BillingCatalogActivationClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        migrated: z.ZodNumber;
+        revision: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=billing-catalog.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/billing-catalog.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const sha = z.string().regex(/^[a-f0-9]{40}$/);
+const name = z
+    .string()
+    .min(1)
+    .max(160)
+    .regex(/^[a-zA-Z0-9._-]+$/);
+const release = z.strictObject({
+    releaseId: name,
+    gitSha: sha,
+    manifestChecksum: digest,
+    imageDigest: digest,
+});
+/** Protected release evidence. No customer-selected plan or allowance is accepted. */
+export const BillingCatalogActivationRequestSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    candidate: release,
+    rollback: release,
+    checkedAt: z.iso.datetime(),
+    revisions: z
+        .array(z.strictObject({ name, gitSha: sha, imageDigest: digest }))
+        .min(1)
+        .max(1000),
+    retiredRevisions: z.array(name).max(1000),
+    jobs: z
+        .array(z.strictObject({ name, activeExecutions: z.literal(0) }))
+        .min(1)
+        .max(1000),
+});
+const statusFields = {
+    version: z.union([z.literal(1), z.literal(2)]),
+    readerVersion: z.literal(2),
+    revision: digest.nullable(),
+};
+export const BillingCatalogStatusResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject(statusFields),
+});
+export const BillingCatalogStatusClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object(statusFields),
+});
+const resultFields = {
+    version: z.literal(2),
+    migrated: z.number().int().nonnegative(),
+    revision: digest,
+};
+export const BillingCatalogActivationResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject(resultFields),
+});
+export const BillingCatalogActivationClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object(resultFields),
+});
+//# sourceMappingURL=billing-catalog.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/billing-enforcement.d.ts

@@ -228,9 +228,9 @@ export type BillingEnforcementActivationApproval = z.infer<typeof BillingEnforce
 export declare const BillingEnforcementActivationStatusSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     state: z.ZodEnum<{
+        active: "active";
         not_activated: "not_activated";
         rolled_back: "rolled_back";
-        active: "active";
     }>;
     generation: z.ZodNumber;
     cohortSealId: z.ZodString;
@@ -245,9 +245,9 @@ export declare const BillingEnforcementActivationStatusSchema: z.ZodObject<{
 export declare const BillingEnforcementActivationStatusClientSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     state: z.ZodEnum<{
+        active: "active";
         not_activated: "not_activated";
         rolled_back: "rolled_back";
-        active: "active";
     }>;
     generation: z.ZodNumber;
     cohortSealId: z.ZodString;
@@ -264,9 +264,9 @@ export declare const BillingEnforcementActivationStatusResponseSchema: z.ZodObje
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         state: z.ZodEnum<{
+            active: "active";
             not_activated: "not_activated";
             rolled_back: "rolled_back";
-            active: "active";
         }>;
         generation: z.ZodNumber;
         cohortSealId: z.ZodString;
@@ -284,9 +284,9 @@ export declare const BillingEnforcementActivationStatusClientResponseSchema: z.Z
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         state: z.ZodEnum<{
+            active: "active";
             not_activated: "not_activated";
             rolled_back: "rolled_back";
-            active: "active";
         }>;
         generation: z.ZodNumber;
         cohortSealId: z.ZodString;
@@ -535,12 +535,12 @@ export declare function parseBillingEnforcementRollbackRequest(value: unknown):
 export declare const BillingEnforcementActivationMutationResultSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     action: z.ZodEnum<{
-        activate: "activate";
         rollback: "rollback";
+        activate: "activate";
     }>;
     state: z.ZodEnum<{
-        rolled_back: "rolled_back";
         active: "active";
+        rolled_back: "rolled_back";
     }>;
     generation: z.ZodNumber;
     replayed: z.ZodBoolean;
@@ -558,12 +558,12 @@ export declare const BillingEnforcementActivationMutationResultSchema: z.ZodObje
 export declare const BillingEnforcementActivationMutationClientResultSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     action: z.ZodEnum<{
-        activate: "activate";
         rollback: "rollback";
+        activate: "activate";
     }>;
     state: z.ZodEnum<{
-        rolled_back: "rolled_back";
         active: "active";
+        rolled_back: "rolled_back";
     }>;
     generation: z.ZodNumber;
     replayed: z.ZodBoolean;
@@ -583,12 +583,12 @@ export declare const BillingEnforcementActivationMutationResponseSchema: z.ZodOb
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         action: z.ZodEnum<{
-            activate: "activate";
             rollback: "rollback";
+            activate: "activate";
         }>;
         state: z.ZodEnum<{
-            rolled_back: "rolled_back";
             active: "active";
+            rolled_back: "rolled_back";
         }>;
         generation: z.ZodNumber;
         replayed: z.ZodBoolean;
@@ -609,12 +609,12 @@ export declare const BillingEnforcementActivationMutationClientResponseSchema: z
     data: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         action: z.ZodEnum<{
-            activate: "activate";
             rollback: "rollback";
+            activate: "activate";
         }>;
         state: z.ZodEnum<{
-            rolled_back: "rolled_back";
             active: "active";
+            rolled_back: "rolled_back";
         }>;
         generation: z.ZodNumber;
         replayed: z.ZodBoolean;

package/node_modules/@noodle-borg/wire-contracts/dist/billing-metering.d.ts

@@ -6,9 +6,9 @@ export declare const BillingMeterReadinessReportSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     checkedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>;
     technicalReadiness: z.ZodEnum<{
+        unavailable: "unavailable";
         ready: "ready";
         blocked: "blocked";
-        unavailable: "unavailable";
     }>;
     metering: z.ZodUnion<readonly [z.ZodObject<{
         mode: z.ZodLiteral<"not_started">;
@@ -51,9 +51,9 @@ export declare const BillingMeterReadinessClientReportSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     checkedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>;
     technicalReadiness: z.ZodEnum<{
+        unavailable: "unavailable";
         ready: "ready";
         blocked: "blocked";
-        unavailable: "unavailable";
     }>;
     metering: z.ZodUnion<readonly [z.ZodObject<{
         mode: z.ZodLiteral<"not_started">;
@@ -98,9 +98,9 @@ export declare const BillingMeterReadinessResponseSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         checkedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>;
         technicalReadiness: z.ZodEnum<{
+            unavailable: "unavailable";
             ready: "ready";
             blocked: "blocked";
-            unavailable: "unavailable";
         }>;
         metering: z.ZodUnion<readonly [z.ZodObject<{
             mode: z.ZodLiteral<"not_started">;
@@ -146,9 +146,9 @@ export declare const BillingMeterReadinessClientResponseSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
         checkedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>;
         technicalReadiness: z.ZodEnum<{
+            unavailable: "unavailable";
             ready: "ready";
             blocked: "blocked";
-            unavailable: "unavailable";
         }>;
         metering: z.ZodUnion<readonly [z.ZodObject<{
             mode: z.ZodLiteral<"not_started">;

package/node_modules/@noodle-borg/wire-contracts/dist/billing-org-transfer.d.ts

@@ -62,8 +62,8 @@ export declare function createBillingOrganizationTransferSchemas(loose: boolean)
                     displayName: z.ZodString;
                 }, z.core.$strict>;
                 state: z.ZodEnum<{
-                    blocked: "blocked";
                     available: "available";
+                    blocked: "blocked";
                     already_linked: "already_linked";
                 }>;
                 warnings: z.ZodArray<z.ZodEnum<{
@@ -208,8 +208,8 @@ export declare const BillingOrganizationTransferCandidatesResponseSchema: z.ZodO
                 displayName: z.ZodString;
             }, z.core.$strict>;
             state: z.ZodEnum<{
-                blocked: "blocked";
                 available: "available";
+                blocked: "blocked";
                 already_linked: "already_linked";
             }>;
             warnings: z.ZodArray<z.ZodEnum<{
@@ -353,8 +353,8 @@ export declare const BillingOrganizationTransferCandidatesClientResponseSchema:
                 displayName: z.ZodString;
             }, z.core.$strict>;
             state: z.ZodEnum<{
-                blocked: "blocked";
                 available: "available";
+                blocked: "blocked";
                 already_linked: "already_linked";
             }>;
             warnings: z.ZodArray<z.ZodEnum<{

package/node_modules/@noodle-borg/wire-contracts/dist/business-information-query.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** Maximum decrypted candidates for a native payload filter/sort query, not a storage quota. */
+export declare const MANAGED_RECORD_QUERY_SCAN_LIMIT = 10000;
+export declare const ManagedRecordQuerySchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>>>;
+    sortField: z.ZodOptional<z.ZodString>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    createdAtFrom: z.ZodOptional<z.ZodISODateTime>;
+    createdAtTo: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type ManagedRecordQuery = z.infer<typeof ManagedRecordQuerySchema>;
+export declare const ManagedRecordQueryErrorSchema: z.ZodObject<{
+    error: z.ZodString;
+    code: z.ZodEnum<{
+        invalid_query: "invalid_query";
+        query_limit_exceeded: "query_limit_exceeded";
+    }>;
+}, z.core.$strict>;
+//# sourceMappingURL=business-information-query.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/business-information-query.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/** Maximum decrypted candidates for a native payload filter/sort query, not a storage quota. */
+export const MANAGED_RECORD_QUERY_SCAN_LIMIT = 10_000;
+export const ManagedRecordQuerySchema = z
+    .object({
+    filters: z
+        .array(z
+        .object({
+        field: z.string().min(1).max(128),
+        value: z.union([z.string().max(4096), z.number().finite(), z.boolean(), z.null()]),
+    })
+        .strict())
+        .max(8)
+        .optional(),
+    sortField: z.string().min(1).max(128).optional(),
+    sortDirection: z.enum(['asc', 'desc']).optional(),
+    createdAtFrom: z.iso.datetime({ offset: true }).optional(),
+    createdAtTo: z.iso.datetime({ offset: true }).optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.sortDirection !== undefined && value.sortField === undefined)
+        context.addIssue({ code: 'custom', message: 'sortDirection requires sortField' });
+    if (value.createdAtFrom !== undefined &&
+        value.createdAtTo !== undefined &&
+        Date.parse(value.createdAtFrom) > Date.parse(value.createdAtTo))
+        context.addIssue({ code: 'custom', message: 'createdAtFrom must not follow createdAtTo' });
+    if (new Set(value.filters?.map((filter) => filter.field)).size !== (value.filters?.length ?? 0))
+        context.addIssue({ code: 'custom', message: 'duplicate filter fields are not allowed' });
+});
+export const ManagedRecordQueryErrorSchema = z
+    .object({
+    error: z.string(),
+    code: z.enum(['invalid_query', 'query_limit_exceeded']),
+})
+    .strict();
+//# sourceMappingURL=business-information-query.js.map