@noodleseed/one 0.161.2 → 0.163.0

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

@@ -0,0 +1,580 @@
+import { z } from 'zod';
+import { BusinessNoticeSchema } from './solution-onboarding.js';
+/** Public Noodle-authored profiles. B2B SaaS uses the private-definition path. */
+export const MANAGED_SOLUTION_PROFILE_IDS = ['travel', 'ecommerce', 'restaurant'];
+export const LEGACY_SOLUTION_PROFILE_IDS = ['b2b_saas'];
+export const SOLUTION_PROFILE_IDS = [
+    ...MANAGED_SOLUTION_PROFILE_IDS,
+    ...LEGACY_SOLUTION_PROFILE_IDS,
+];
+export const ManagedSolutionProfileIdSchema = z.enum(MANAGED_SOLUTION_PROFILE_IDS);
+export const LegacySolutionProfileIdSchema = z.enum(LEGACY_SOLUTION_PROFILE_IDS);
+/** Read compatibility for persisted identifiers; never use this schema for new catalog entries. */
+export const SolutionProfileIdSchema = z.enum(SOLUTION_PROFILE_IDS);
+export const MANAGED_RECORD_RETENTION_DAYS = [7, 30, 90];
+export const ManagedRecordRetentionDaysSchema = z.union([
+    z.literal(7),
+    z.literal(30),
+    z.literal(90),
+]);
+/** Optional request-application behavior; not a universal collection lifecycle. */
+export const MANAGED_RECORD_STATUSES = ['new', 'in_progress', 'resolved', 'closed'];
+export const ManagedRecordStatusSchema = z.enum(MANAGED_RECORD_STATUSES);
+export const BUSINESS_GRANT_ROLES = ['administrator', 'manager', 'operator', 'viewer'];
+export const BusinessGrantRoleSchema = z.enum(BUSINESS_GRANT_ROLES);
+export const MANAGED_RECORD_ORIGIN_SURFACES = ['public', 'portal', 'mcp', 'api'];
+export const ManagedRecordOriginSurfaceSchema = z.enum(MANAGED_RECORD_ORIGIN_SURFACES);
+export const COLLECTION_SOURCE_HEALTH_STATES = [
+    'pending',
+    'healthy',
+    'degraded',
+    'unavailable',
+    'authorization_required',
+    'paused',
+];
+export const CollectionSourceHealthSchema = z.enum(COLLECTION_SOURCE_HEALTH_STATES);
+export const COLLECTION_SOURCE_COMPLETENESS_STATES = [
+    'unknown',
+    'partial',
+    'complete',
+    'rebuilding',
+];
+export const CollectionSourceCompletenessSchema = z.enum(COLLECTION_SOURCE_COMPLETENESS_STATES);
+const id = z.string().min(1).max(128);
+const slug = z
+    .string()
+    .regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/)
+    .max(63);
+const collectionKey = z
+    .string()
+    .regex(/^[a-z][a-z0-9_]*$/)
+    .max(64);
+const operationName = z
+    .string()
+    .regex(/^[a-z][a-z0-9_]*$/)
+    .max(64);
+const instant = z.iso.datetime({ offset: true });
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const jsonObject = z.record(z.string(), z.unknown());
+const positiveRevision = z.number().int().positive();
+const collectionProfileShape = {
+    key: collectionKey,
+    title: z.string().min(1).max(120),
+    singularTitle: z.string().min(1).max(120),
+    schemaVersion: z.number().int().positive(),
+    schemaDigest: digest,
+    recordSchema: jsonObject,
+    summaryFields: z.array(z.string().min(1).max(64)).max(128),
+    fields: z
+        .record(z.string().min(1).max(64), z.strictObject({
+        label: z.string().min(1).max(120).optional(),
+        help: z.string().max(1000).optional(),
+    }))
+        .optional(),
+    filterFields: z.array(z.string().min(1).max(64)).max(128).optional(),
+    sortFields: z.array(z.string().min(1).max(64)).max(128).optional(),
+};
+export const ManagedRequestBehaviorSchema = z.strictObject({
+    statuses: z.array(ManagedRecordStatusSchema).min(1).max(MANAGED_RECORD_STATUSES.length),
+    assignment: z.boolean(),
+    notes: z.boolean(),
+});
+export const NativeManagedCollectionProfileSchema = z.strictObject({
+    authority: z.literal('native'),
+    ...collectionProfileShape,
+    management: z
+        .strictObject({ assignment: z.literal(true).optional(), notes: z.literal(true).optional() })
+        .optional(),
+    publicFields: z.array(z.string().min(1).max(64)).max(128).optional(),
+    editableFields: z.array(z.string().min(1).max(64)).max(128).optional(),
+    capabilities: z.strictObject({
+        read: z.literal(true),
+        create: z.literal(true),
+        update: z.literal(true),
+        erase: z.literal(true),
+        sourceControls: z.literal(false),
+    }),
+    requestBehavior: ManagedRequestBehaviorSchema.optional(),
+});
+export const ExternalManagedCollectionProfileSchema = z.strictObject({
+    authority: z.literal('external'),
+    ...collectionProfileShape,
+    capabilities: z.strictObject({
+        read: z.literal(true),
+        create: z.literal(false),
+        update: z.literal(false),
+        erase: z.literal(true),
+        sourceControls: z.literal(true),
+    }),
+    source: z.strictObject({
+        connector: id,
+        scanOperation: operationName,
+    }),
+});
+export const ManagedCollectionProfileSchema = z.discriminatedUnion('authority', [
+    NativeManagedCollectionProfileSchema,
+    ExternalManagedCollectionProfileSchema,
+]);
+export const SolutionProfileSchema = z.strictObject({
+    id: ManagedSolutionProfileIdSchema,
+    title: z.string().min(1).max(80),
+    description: z.string().min(1).max(240),
+    collections: z.array(ManagedCollectionProfileSchema).min(1).max(12),
+});
+export const SolutionCatalogResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        profiles: z.array(SolutionProfileSchema).max(MANAGED_SOLUTION_PROFILE_IDS.length),
+    }),
+});
+export const ManagedSolutionDefinitionSelectorSchema = z.strictObject({
+    kind: z.literal('managed'),
+    profileId: ManagedSolutionProfileIdSchema,
+});
+export const PrivateSolutionDefinitionReferenceSchema = z.strictObject({
+    kind: z.literal('private'),
+    publisherOrg: id,
+    app: slug,
+    environment: z.string().min(1).max(63),
+    deploymentId: id,
+});
+export const InstallableSolutionDefinitionSchema = z.discriminatedUnion('kind', [
+    ManagedSolutionDefinitionSelectorSchema,
+    PrivateSolutionDefinitionReferenceSchema,
+]);
+export const SolutionInstallationCreateRequestSchema = z.strictObject({
+    businessNotice: BusinessNoticeSchema.optional(),
+    definition: InstallableSolutionDefinitionSchema,
+    appSlug: slug,
+    environment: z.string().min(1).max(63),
+    retentionDays: ManagedRecordRetentionDaysSchema,
+});
+export const SolutionInstallationIntakeRequestSchema = z.strictObject({
+    active: z.boolean(),
+    expectedRevision: positiveRevision,
+});
+const installationShape = {
+    id,
+    organizationId: id,
+    appSlug: slug,
+    environment: z.string().min(1).max(63),
+    retentionDays: ManagedRecordRetentionDaysSchema,
+    publicId: id,
+    active: z.boolean(),
+    currentRole: BusinessGrantRoleSchema,
+    revision: positiveRevision,
+    createdAt: instant,
+    updatedAt: instant,
+    createdBySubject: id,
+};
+export const ResolvedManagedSolutionDefinitionSchema = z.strictObject({
+    kind: z.literal('managed'),
+    definitionId: ManagedSolutionProfileIdSchema,
+    release: z.number().int().positive(),
+    digest,
+});
+export const ResolvedPrivateSolutionDefinitionSchema = z.strictObject({
+    kind: z.literal('private'),
+    publisherOrg: id,
+    app: slug,
+    environment: z.string().min(1).max(63),
+    deploymentId: id,
+    version: z.string().min(1).max(128),
+    digest,
+});
+export const ResolvedLegacySolutionDefinitionSchema = z.strictObject({
+    kind: z.literal('legacy'),
+    definitionId: LegacySolutionProfileIdSchema,
+    release: z.number().int().positive(),
+    digest,
+});
+export const ResolvedSolutionDefinitionSchema = z.discriminatedUnion('kind', [
+    ResolvedManagedSolutionDefinitionSchema,
+    ResolvedPrivateSolutionDefinitionSchema,
+    ResolvedLegacySolutionDefinitionSchema,
+]);
+export const SolutionInstallationSchema = z.strictObject({
+    ...installationShape,
+    definition: ResolvedSolutionDefinitionSchema,
+    collections: z.array(ManagedCollectionProfileSchema).max(16),
+    /** Historical persisted key retained only while legacy installations are backfilled. */
+    profileId: LegacySolutionProfileIdSchema.optional(),
+});
+export const SolutionInstallationResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ installation: SolutionInstallationSchema }),
+});
+export const SolutionInstallationListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        installations: z.array(SolutionInstallationSchema).max(100),
+        nextCursor: z.string().min(1).max(1024).optional(),
+    }),
+});
+export const BusinessGrantCreateRequestSchema = z.strictObject({
+    subject: id,
+    email: z.email().max(254),
+    role: BusinessGrantRoleSchema,
+    expectedRevision: z.number().int().nonnegative().optional(),
+});
+export const BusinessGrantSchema = z.strictObject({
+    installationId: id,
+    subject: id,
+    email: z.email().max(254),
+    role: BusinessGrantRoleSchema,
+    revision: positiveRevision,
+    createdAt: instant,
+    createdBySubject: id,
+    revokedAt: instant.optional(),
+});
+export const BusinessGrantResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ grant: BusinessGrantSchema }),
+});
+export const BusinessGrantListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ grants: z.array(BusinessGrantSchema).max(100) }),
+});
+export const BUSINESS_INVITATION_STATUSES = ['pending', 'accepted', 'revoked', 'expired'];
+export const BusinessInvitationStatusSchema = z.enum(BUSINESS_INVITATION_STATUSES);
+/** The raw token is supplied by the trusted client and is never persisted by the service. */
+export const BusinessInvitationCreateRequestSchema = z.strictObject({
+    email: z.email().max(254),
+    role: BusinessGrantRoleSchema,
+    token: z.string().regex(/^[A-Za-z0-9_-]{43,128}$/),
+    idempotencyKey: z.string().min(1).max(128),
+    expiresInHours: z.number().int().min(1).max(168).default(168),
+});
+export const BusinessInvitationRevokeRequestSchema = z.strictObject({
+    expectedRevision: positiveRevision,
+});
+export const BusinessInvitationSchema = z.strictObject({
+    invitationId: id,
+    installationId: id,
+    email: z.email().max(254),
+    role: BusinessGrantRoleSchema,
+    status: BusinessInvitationStatusSchema,
+    revision: positiveRevision,
+    createdAt: instant,
+    expiresAt: instant,
+    createdBySubject: id,
+    acceptedAt: instant.optional(),
+    revokedAt: instant.optional(),
+});
+export const BusinessInvitationResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ invitation: BusinessInvitationSchema }),
+});
+export const BusinessInvitationCreateResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        invitation: BusinessInvitationSchema,
+        acceptPath: z.string().startsWith('/portal-invitations/').max(512),
+        replayed: z.boolean(),
+    }),
+});
+export const BusinessInvitationListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ invitations: z.array(BusinessInvitationSchema).max(100) }),
+});
+export const BusinessInvitationAcceptResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        installation: SolutionInstallationSchema,
+        grant: BusinessGrantSchema,
+    }),
+});
+export const EligibleBusinessAssigneeSchema = z.strictObject({
+    subject: id,
+    email: z.email().max(254),
+    role: z.enum(['administrator', 'manager', 'operator']),
+});
+export const EligibleBusinessAssigneeListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ assignees: z.array(EligibleBusinessAssigneeSchema).max(100) }),
+});
+export const ManagedRecordCreateRequestSchema = z.strictObject({ payload: jsonObject });
+export const ManagedRecordOriginSchema = z.strictObject({
+    surface: ManagedRecordOriginSurfaceSchema,
+    subject: id.optional(),
+});
+export const ManagedRecordRequestStateSchema = z.strictObject({
+    status: ManagedRecordStatusSchema,
+    assigneeSubject: id.optional(),
+});
+const recordShape = {
+    id,
+    organizationId: id,
+    appSlug: slug,
+    environment: z.string().min(1).max(63),
+    installationId: id,
+    collection: collectionKey,
+    schemaVersion: z.number().int().positive(),
+    schemaDigest: digest,
+    payload: jsonObject,
+    revision: positiveRevision,
+    createdAt: instant,
+    updatedAt: instant,
+    retentionExpiresAt: instant,
+};
+export const NativeManagedRecordSchema = z.strictObject({
+    authority: z.literal('native'),
+    ...recordShape,
+    origin: ManagedRecordOriginSchema,
+    assigneeSubject: id.optional(),
+    request: ManagedRecordRequestStateSchema.optional(),
+});
+export const ExternalManagedRecordSourceSchema = z.strictObject({
+    bindingReference: id,
+    bindingGeneration: z.number().int().positive(),
+    sourceRecordId: id,
+    sourceVersion: z.string().min(1).max(512).optional(),
+    observedAt: instant,
+    lastCompletedSyncAt: instant,
+    health: CollectionSourceHealthSchema,
+    completeness: CollectionSourceCompletenessSchema,
+});
+export const ExternalManagedRecordSchema = z.strictObject({
+    authority: z.literal('external'),
+    ...recordShape,
+    source: ExternalManagedRecordSourceSchema,
+});
+export const ManagedRecordSchema = z.discriminatedUnion('authority', [
+    NativeManagedRecordSchema,
+    ExternalManagedRecordSchema,
+]);
+const tombstoneShape = {
+    id,
+    organizationId: id,
+    appSlug: slug,
+    environment: z.string().min(1).max(63),
+    installationId: id,
+    collection: collectionKey,
+    revision: positiveRevision,
+    deletedAt: instant,
+};
+export const NativeManagedRecordTombstoneSchema = z.strictObject({
+    authority: z.literal('native'),
+    ...tombstoneShape,
+    deletionReason: z.enum(['customer_request', 'retention_expired']),
+});
+export const ExternalManagedRecordSuppressionSchema = z.strictObject({
+    authority: z.literal('external'),
+    ...tombstoneShape,
+    deletionReason: z.literal('customer_request'),
+    source: z.strictObject({
+        bindingReference: id,
+        bindingGeneration: z.number().int().positive(),
+        sourceRecordId: id,
+    }),
+});
+export const ManagedRecordTombstoneSchema = z.discriminatedUnion('authority', [
+    NativeManagedRecordTombstoneSchema,
+    ExternalManagedRecordSuppressionSchema,
+]);
+export const ManagedRecordResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        record: ManagedRecordSchema,
+        collection: ManagedCollectionProfileSchema.optional(),
+    }),
+});
+const managedRecordOrTombstone = z.union([ManagedRecordSchema, ManagedRecordTombstoneSchema]);
+export const ManagedRecordListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        records: z.array(managedRecordOrTombstone).max(100),
+        nextCursor: z.string().min(1).optional(),
+    }),
+});
+export const ManagedRecordMutationRequestSchema = z.discriminatedUnion('operation', [
+    z.strictObject({ operation: z.literal('migrate-schema'), expectedRevision: positiveRevision }),
+    z.strictObject({
+        operation: z.literal('update'),
+        expectedRevision: positiveRevision,
+        patch: jsonObject,
+        unset: z
+            .array(z.string().min(1).max(64))
+            .max(128)
+            .refine((keys) => new Set(keys).size === keys.length)
+            .optional(),
+    }),
+    z.strictObject({
+        operation: z.literal('assign'),
+        expectedRevision: positiveRevision,
+        assigneeSubject: id.nullable(),
+    }),
+    z.strictObject({
+        operation: z.literal('set-status'),
+        expectedRevision: positiveRevision,
+        status: ManagedRecordStatusSchema,
+    }),
+    z.strictObject({
+        operation: z.literal('add-note'),
+        expectedRevision: positiveRevision,
+        note: z.string().min(1).max(4_000),
+    }),
+]);
+export const BusinessApiAdmissionErrorSchema = z.discriminatedUnion('code', [
+    z.strictObject({
+        code: z.literal('business_api_rate_limited'),
+        error: z.string().min(1).max(500),
+        category: z.enum(['read', 'mutation', 'recovery']),
+        resetAt: z.iso.datetime(),
+        limits: z.strictObject({
+            subject: z.number().int().positive(),
+            installation: z.number().int().positive(),
+            org: z.number().int().positive(),
+        }),
+    }),
+    z.strictObject({
+        code: z.literal('business_api_admission_unavailable'),
+        error: z.string().min(1).max(500),
+    }),
+]);
+export const SolutionInstallationCapacityErrorSchema = z.strictObject({
+    code: z.literal('installation_capacity_exceeded'),
+    error: z.string().min(1).max(500),
+});
+export const ManagedRecordOperationNotSupportedErrorSchema = z.strictObject({
+    ok: z.literal(false),
+    error: z.string().min(1).max(500),
+    code: z.literal('operation_not_supported'),
+    details: z.strictObject({
+        authority: z.literal('external'),
+        operation: z.enum(['create', 'update', 'assign', 'set-status', 'add-note', 'migrate-schema']),
+    }),
+});
+export const ManagedRecordActivitySchema = z.strictObject({
+    id,
+    recordId: id,
+    revision: positiveRevision,
+    operation: z.enum([
+        'create',
+        'update',
+        'assign',
+        'set-status',
+        'add-note',
+        'delete',
+        'source-import',
+        'schema-migrated',
+        'source-delete',
+        'suppress',
+    ]),
+    actorSubject: id.optional(),
+    createdAt: instant,
+    note: z.string().max(4_000).optional(),
+});
+export const ManagedRecordActivityListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        activities: z.array(ManagedRecordActivitySchema).max(100),
+        nextCursor: z.string().max(2048).optional(),
+    }),
+});
+export const ManagedRecordDeleteResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        recordId: id,
+        authority: z.enum(['native', 'external']),
+        disposition: z.enum(['deleted', 'suppressed']),
+        deletedAt: instant,
+    }),
+});
+export const ManagedRecordNoteSchema = z.strictObject({
+    id,
+    text: z.string().max(4_000),
+    createdAt: instant,
+    createdBySubject: id,
+});
+export const ManagedRecordExportResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        records: z
+            .array(z.union([
+            NativeManagedRecordSchema.extend({
+                notes: z.array(ManagedRecordNoteSchema).max(50).optional(),
+            }),
+            ExternalManagedRecordSchema,
+            ManagedRecordTombstoneSchema,
+        ]))
+            .max(500),
+        nextCursor: z.string().min(1).optional(),
+    }),
+});
+const sourceScopeShape = {
+    installationId: id,
+    collection: collectionKey,
+    authority: z.literal('external'),
+    revision: positiveRevision,
+};
+const sourceError = z.strictObject({
+    code: z.string().min(1).max(128),
+    message: z.string().min(1).max(500),
+    retryable: z.boolean(),
+});
+export const UnconfiguredCollectionSourceSchema = z.strictObject({
+    ...sourceScopeShape,
+    state: z.literal('unconfigured'),
+});
+export const ConfiguredCollectionSourceSchema = z.strictObject({
+    ...sourceScopeShape,
+    state: z.enum(['active', 'paused', 'error']),
+    binding: z.strictObject({ reference: id, generation: z.number().int().positive() }),
+    configurationReference: id,
+    enabled: z.literal(true),
+    health: CollectionSourceHealthSchema,
+    completeness: CollectionSourceCompletenessSchema,
+    lastCompletedSyncAt: instant.optional(),
+    nextRefreshAt: instant.optional(),
+    error: sourceError.optional(),
+});
+export const CollectionSourceSchema = z.discriminatedUnion('state', [
+    UnconfiguredCollectionSourceSchema,
+    ConfiguredCollectionSourceSchema,
+]);
+export const CollectionSourceConfigureRequestSchema = z.strictObject({
+    expectedRevision: positiveRevision,
+    binding: z.strictObject({ reference: id, generation: z.number().int().positive() }),
+    configurationReference: id,
+    enable: z.literal(true),
+    replace: z.literal(true).optional(),
+});
+export const CollectionSourceRevisionRequestSchema = z.strictObject({
+    expectedRevision: positiveRevision,
+});
+export const CollectionSourceRefreshRequestSchema = z.strictObject({
+    expectedRevision: positiveRevision,
+    idempotencyKey: z.string().min(1).max(256),
+});
+export const CollectionSourceResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ source: CollectionSourceSchema }),
+});
+export const CollectionSourceRefreshResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        source: CollectionSourceSchema,
+        job: z.strictObject({
+            id,
+            state: z.enum(['queued', 'running', 'completed', 'superseded']),
+            coalesced: z.boolean(),
+            requestedAt: instant,
+            replayExpiresAt: instant.optional(),
+        }),
+    }),
+});
+export const PublicSolutionIntakeResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        publicId: id,
+        title: z.string().min(1).max(120),
+        description: z.string().min(1).max(240),
+        collection: NativeManagedCollectionProfileSchema,
+    }),
+});
+export const PublicSolutionIntakeReceiptResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ recordId: id, receivedAt: instant }),
+});
+//# sourceMappingURL=business-information.js.map

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

@@ -569,12 +569,12 @@ export declare const DeployRunSchema: z.ZodObject<{
     prNumber: z.ZodOptional<z.ZodNumber>;
     status: z.ZodEnum<{
         queued: "queued";
+        superseded: "superseded";
         building: "building";
         deploying: "deploying";
         deployed: "deployed";
         failed: "failed";
         canceled: "canceled";
-        superseded: "superseded";
     }>;
     blockedReason: z.ZodOptional<z.ZodString>;
     deploymentId: z.ZodOptional<z.ZodString>;
@@ -605,12 +605,12 @@ export declare const GithubRunsListResponseSchema: z.ZodObject<{
             prNumber: z.ZodOptional<z.ZodNumber>;
             status: z.ZodEnum<{
                 queued: "queued";
+                superseded: "superseded";
                 building: "building";
                 deploying: "deploying";
                 deployed: "deployed";
                 failed: "failed";
                 canceled: "canceled";
-                superseded: "superseded";
             }>;
             blockedReason: z.ZodOptional<z.ZodString>;
             deploymentId: z.ZodOptional<z.ZodString>;

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

@@ -85,11 +85,11 @@ export declare const DistributionReadinessStatusSchema: z.ZodEnum<{
     draft: "draft";
 }>;
 export declare const DistributionHumanReviewStatusSchema: z.ZodEnum<{
+    rejected: "rejected";
     submitted: "submitted";
     "in-review": "in-review";
     "changes-requested": "changes-requested";
     approved: "approved";
-    rejected: "rejected";
     published: "published";
     withdrawn: "withdrawn";
 }>;
@@ -126,11 +126,11 @@ export declare const DistributionLifecycleSchema: z.ZodObject<{
     review: z.ZodOptional<z.ZodObject<{
         source: z.ZodLiteral<"human">;
         reportedStatus: z.ZodEnum<{
+            rejected: "rejected";
             submitted: "submitted";
             "in-review": "in-review";
             "changes-requested": "changes-requested";
             approved: "approved";
-            rejected: "rejected";
             published: "published";
             withdrawn: "withdrawn";
         }>;
@@ -179,11 +179,11 @@ export declare const DistributionReadinessRequestSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const DistributionHumanReviewRequestSchema: z.ZodObject<{
     reportedStatus: z.ZodEnum<{
+        rejected: "rejected";
         submitted: "submitted";
         "in-review": "in-review";
         "changes-requested": "changes-requested";
         approved: "approved";
-        rejected: "rejected";
         published: "published";
         withdrawn: "withdrawn";
     }>;
@@ -311,11 +311,11 @@ export declare const DistributionResponseSchema: z.ZodObject<{
         review: z.ZodOptional<z.ZodObject<{
             source: z.ZodLiteral<"human">;
             reportedStatus: z.ZodEnum<{
+                rejected: "rejected";
                 submitted: "submitted";
                 "in-review": "in-review";
                 "changes-requested": "changes-requested";
                 approved: "approved";
-                rejected: "rejected";
                 published: "published";
                 withdrawn: "withdrawn";
             }>;
@@ -461,11 +461,11 @@ export declare const DistributionLifecycleResponseSchema: z.ZodObject<{
             review: z.ZodOptional<z.ZodObject<{
                 source: z.ZodLiteral<"human">;
                 reportedStatus: z.ZodEnum<{
+                    rejected: "rejected";
                     submitted: "submitted";
                     "in-review": "in-review";
                     "changes-requested": "changes-requested";
                     approved: "approved";
-                    rejected: "rejected";
                     published: "published";
                     withdrawn: "withdrawn";
                 }>;