@sourcey/catalog-verifier 1.0.0

package/SOURCEY-DISTRIBUTION.json

@@ -0,0 +1,24 @@
+{
+  "code_distribution_definition_contract": "sourcey.code-distribution-definition/v1",
+  "distribution_id": "catalog-verifier",
+  "package_name": "@sourcey/catalog-verifier",
+  "description": "Validate changed Catalog YAML and verify immutable Sourcey release bundles.",
+  "audience": "Public Catalog pull-request CI, Sourcey release construction, and isolated release custody.",
+  "channel": "One purpose-scoped closure projected as a content-addressed Sourcey artifact and the public @sourcey/catalog-verifier npm package.",
+  "entries": {
+    ".": "index"
+  },
+  "bin": {
+    "sourcey-catalog-verify": "program"
+  },
+  "extras": ["taxonomy.json"],
+  "forbidden_closure_prefixes": [
+    "dist/apps/",
+    "dist/modules/evidence-operations/src/discovery-scanner",
+    "dist/modules/evidence-operations/src/offer-harvest",
+    "dist/modules/evidence-operations/src/offer-refresh",
+    "dist/modules/evidence-operations/src/source-inventory",
+    "dist/modules/evidence-operations/src/workflow"
+  ],
+  "dependencies": ["parse5", "yaml", "zod"]
+}

package/SOURCEY-LICENSE-POLICY.json

@@ -0,0 +1,5 @@
+{
+  "code_distribution_license_policy_contract": "sourcey.code-distribution-license-policy/v1",
+  "package_license": "MIT",
+  "allowed_dependency_licenses": ["Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "MIT"]
+}

package/SOURCEY-TOOLCHAIN.json

@@ -0,0 +1,8 @@
+{
+  "code_distribution_toolchain_contract": "sourcey.code-distribution-toolchain/v1",
+  "node": "22.23.1",
+  "npm": "11.12.1",
+  "typescript": "6.0.3",
+  "archive_format": "sourcey-canonical-tar-gzip/v1",
+  "archive_extension": ".tar.gz"
+}

package/SUPPORT.md

@@ -0,0 +1,5 @@
+# Support
+
+Use GitHub issues for reproducible verifier defects and documentation gaps.
+Include the exact package version, command, repository kind, diagnostic rule ID,
+and redacted input shape. Do not attach credentials or private evidence.

package/THIRD_PARTY_NOTICES.json

@@ -0,0 +1,69 @@
+{
+  "code_distribution_notices_contract": "sourcey.code-distribution-notices/v1",
+  "distribution_id": "catalog-verifier",
+  "package_name": "@sourcey/catalog-verifier",
+  "package_license": "MIT",
+  "license_policy_sha256": "sha256:7cb7eafd85fcb99d00715142932da6b06f984121fb139ad5256b315c17c7609e",
+  "dependencies": [
+    {
+      "name": "entities",
+      "version": "8.0.0",
+      "license": "BSD-2-Clause",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "lock_path": "node_modules/entities",
+      "license_files": [
+        {
+          "path": "node_modules/entities/LICENSE",
+          "sha256": "sha256:cb992345949ccd6e8394b2cd6c465f7b897c864f845937dbf64e8997f389e164",
+          "bytes": 1260
+        }
+      ]
+    },
+    {
+      "name": "parse5",
+      "version": "8.0.1",
+      "license": "MIT",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+      "lock_path": "node_modules/parse5",
+      "license_files": [
+        {
+          "path": "node_modules/parse5/LICENSE",
+          "sha256": "sha256:8c535800331e1e4439835555b3f9edc7fe9dee2fab0d8bbbd5a982e8b8343d4d",
+          "bytes": 1109
+        }
+      ]
+    },
+    {
+      "name": "yaml",
+      "version": "2.9.0",
+      "license": "ISC",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
+      "lock_path": "node_modules/yaml",
+      "license_files": [
+        {
+          "path": "node_modules/yaml/LICENSE",
+          "sha256": "sha256:5bba27375d93e9119f76c1015f7672cf9ad5f70952296e0842fb2243d6376869",
+          "bytes": 738
+        }
+      ]
+    },
+    {
+      "name": "zod",
+      "version": "4.4.3",
+      "license": "MIT",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "lock_path": "node_modules/zod",
+      "license_files": [
+        {
+          "path": "node_modules/zod/LICENSE",
+          "sha256": "sha256:3f1189b28e3866e0d979968d466b78f813f76827cfdca1fbb124cc0a5c8841f8",
+          "bytes": 1072
+        }
+      ]
+    }
+  ]
+}

package/dist/contracts/agent-readiness/src/declaration-acquisition.d.ts

@@ -0,0 +1,548 @@
+import { z } from "zod";
+export declare const agentReadinessDraftSubjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"entity_id">;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"slug">;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"domain">;
+    value: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const agentReadinessDraftParticipantSchema: z.ZodObject<{
+    participant_id: z.ZodString;
+    roles: z.ZodArray<z.ZodEnum<{
+        access_operator: "access_operator";
+        identity_provider: "identity_provider";
+        payment_provider: "payment_provider";
+        provisioning_provider: "provisioning_provider";
+        operations_provider: "operations_provider";
+    }>>;
+    identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"entity_id">;
+        entity_id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"origin_uri">;
+        uri: z.ZodURL;
+    }, z.core.$strict>], "kind">;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftResourceSchema: z.ZodObject<{
+    resource_id: z.ZodString;
+    uri: z.ZodURL;
+    roles: z.ZodArray<z.ZodEnum<{
+        policy: "policy";
+        discovery: "discovery";
+        status: "status";
+        pricing: "pricing";
+        eligibility: "eligibility";
+        access: "access";
+        terms: "terms";
+        checkout: "checkout";
+        provisioning: "provisioning";
+        operations: "operations";
+        recovery: "recovery";
+        authentication: "authentication";
+        descriptor: "descriptor";
+        documentation: "documentation";
+    }>>;
+    operated_by_participant_id: z.ZodString;
+    standard_bindings: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        version: z.ZodString;
+        relation: z.ZodEnum<{
+            declares: "declares";
+            describes: "describes";
+            implements: "implements";
+            uses: "uses";
+        }>;
+    }, z.core.$strict>>;
+    allowed_redirect_hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftEndpointSchema: z.ZodObject<{
+    endpoint_id: z.ZodString;
+    uri: z.ZodURL;
+    transport: z.ZodEnum<{
+        http: "http";
+        websocket: "websocket";
+        grpc: "grpc";
+    }>;
+    roles: z.ZodArray<z.ZodEnum<{
+        status: "status";
+        service: "service";
+        checkout: "checkout";
+        recovery: "recovery";
+        authorization: "authorization";
+        token: "token";
+        registration: "registration";
+        protected_resource: "protected_resource";
+        webhook: "webhook";
+    }>>;
+    operated_by_participant_id: z.ZodString;
+    standard_bindings: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        version: z.ZodString;
+        relation: z.ZodEnum<{
+            declares: "declares";
+            describes: "describes";
+            implements: "implements";
+            uses: "uses";
+        }>;
+    }, z.core.$strict>>;
+    allowed_redirect_hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftInterfaceSchema: z.ZodObject<{
+    interface_id: z.ZodString;
+    modality: z.ZodEnum<{
+        web_application: "web_application";
+        network_api: "network_api";
+        command_line: "command_line";
+        software_library: "software_library";
+        tool_server: "tool_server";
+        agent_service: "agent_service";
+    }>;
+    functions: z.ZodArray<z.ZodEnum<{
+        events: "events";
+        recovery: "recovery";
+        authentication: "authentication";
+        service_operation: "service_operation";
+        commerce: "commerce";
+    }>>;
+    endpoint_ids: z.ZodArray<z.ZodString>;
+    resource_ids: z.ZodArray<z.ZodString>;
+    operated_by_participant_id: z.ZodString;
+    standard_bindings: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        version: z.ZodString;
+        relation: z.ZodEnum<{
+            declares: "declares";
+            describes: "describes";
+            implements: "implements";
+            uses: "uses";
+        }>;
+    }, z.core.$strict>>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftAssessmentTargetSchema: z.ZodObject<{
+    target_id: z.ZodString;
+    name: z.ZodString;
+    interface_ids: z.ZodArray<z.ZodString>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftRelationSchema: z.ZodObject<{
+    relation_id: z.ZodString;
+    kind: z.ZodEnum<{
+        describes: "describes";
+        authenticates: "authenticates";
+        requires: "requires";
+        alternative_to: "alternative_to";
+        precedes: "precedes";
+    }>;
+    from: z.ZodObject<{
+        node_kind: z.ZodEnum<{
+            resource: "resource";
+            endpoint: "endpoint";
+            interface: "interface";
+            surface_exclusion: "surface_exclusion";
+        }>;
+        node_id: z.ZodString;
+    }, z.core.$strict>;
+    to: z.ZodObject<{
+        node_kind: z.ZodEnum<{
+            resource: "resource";
+            endpoint: "endpoint";
+            interface: "interface";
+            surface_exclusion: "surface_exclusion";
+        }>;
+        node_id: z.ZodString;
+    }, z.core.$strict>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftOfferRelationSchema: z.ZodObject<{
+    offer_relation_proposal_id: z.ZodString;
+    offer_id: z.ZodString;
+    purpose: z.ZodEnum<{
+        application_path: "application_path";
+        redemption_path: "redemption_path";
+        operating_path: "operating_path";
+    }>;
+    applicable_stages: z.ZodArray<z.ZodEnum<{
+        evaluate: "evaluate";
+        sign_up: "sign_up";
+        pay: "pay";
+        provision: "provision";
+        operate: "operate";
+    }>>;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftSurfaceExclusionSchema: z.ZodObject<{
+    exclusion_id: z.ZodString;
+    role: z.ZodEnum<{
+        policy: "policy";
+        discovery: "discovery";
+        status: "status";
+        pricing: "pricing";
+        eligibility: "eligibility";
+        access: "access";
+        terms: "terms";
+        checkout: "checkout";
+        provisioning: "provisioning";
+        operations: "operations";
+        recovery: "recovery";
+        authentication: "authentication";
+        descriptor: "descriptor";
+        documentation: "documentation";
+    }>;
+    rationale: z.ZodString;
+    source_uris: z.ZodArray<z.ZodURL>;
+}, z.core.$strict>;
+/**
+ * Transient command input. Its semantic fields are composed directly from the
+ * canonical declaration schemas; only deterministic authoring boilerplate is
+ * absent. This object is never a repository format or release record.
+ */
+export declare const agentReadinessDeclarationDraftRequestSchema: z.ZodObject<{
+    command_contract: z.ZodLiteral<"sourcey.agent-readiness-declaration-draft/v1alpha1">;
+    subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"entity_id">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"slug">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"domain">;
+        value: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    scope: z.ZodOptional<z.ZodObject<{
+        product: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        funnel: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    scope_source_uris: z.ZodDefault<z.ZodArray<z.ZodURL>>;
+    subject_roles: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        access_operator: "access_operator";
+        identity_provider: "identity_provider";
+        payment_provider: "payment_provider";
+        provisioning_provider: "provisioning_provider";
+        operations_provider: "operations_provider";
+    }>>>;
+    assessment_targets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        target_id: z.ZodString;
+        name: z.ZodString;
+        interface_ids: z.ZodArray<z.ZodString>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    participants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        participant_id: z.ZodString;
+        roles: z.ZodArray<z.ZodEnum<{
+            access_operator: "access_operator";
+            identity_provider: "identity_provider";
+            payment_provider: "payment_provider";
+            provisioning_provider: "provisioning_provider";
+            operations_provider: "operations_provider";
+        }>>;
+        identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"entity_id">;
+            entity_id: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_uri">;
+            uri: z.ZodURL;
+        }, z.core.$strict>], "kind">;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    resources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        resource_id: z.ZodString;
+        uri: z.ZodURL;
+        roles: z.ZodArray<z.ZodEnum<{
+            policy: "policy";
+            discovery: "discovery";
+            status: "status";
+            pricing: "pricing";
+            eligibility: "eligibility";
+            access: "access";
+            terms: "terms";
+            checkout: "checkout";
+            provisioning: "provisioning";
+            operations: "operations";
+            recovery: "recovery";
+            authentication: "authentication";
+            descriptor: "descriptor";
+            documentation: "documentation";
+        }>>;
+        operated_by_participant_id: z.ZodString;
+        standard_bindings: z.ZodArray<z.ZodObject<{
+            namespace: z.ZodString;
+            version: z.ZodString;
+            relation: z.ZodEnum<{
+                declares: "declares";
+                describes: "describes";
+                implements: "implements";
+                uses: "uses";
+            }>;
+        }, z.core.$strict>>;
+        allowed_redirect_hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        endpoint_id: z.ZodString;
+        uri: z.ZodURL;
+        transport: z.ZodEnum<{
+            http: "http";
+            websocket: "websocket";
+            grpc: "grpc";
+        }>;
+        roles: z.ZodArray<z.ZodEnum<{
+            status: "status";
+            service: "service";
+            checkout: "checkout";
+            recovery: "recovery";
+            authorization: "authorization";
+            token: "token";
+            registration: "registration";
+            protected_resource: "protected_resource";
+            webhook: "webhook";
+        }>>;
+        operated_by_participant_id: z.ZodString;
+        standard_bindings: z.ZodArray<z.ZodObject<{
+            namespace: z.ZodString;
+            version: z.ZodString;
+            relation: z.ZodEnum<{
+                declares: "declares";
+                describes: "describes";
+                implements: "implements";
+                uses: "uses";
+            }>;
+        }, z.core.$strict>>;
+        allowed_redirect_hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    interfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        interface_id: z.ZodString;
+        modality: z.ZodEnum<{
+            web_application: "web_application";
+            network_api: "network_api";
+            command_line: "command_line";
+            software_library: "software_library";
+            tool_server: "tool_server";
+            agent_service: "agent_service";
+        }>;
+        functions: z.ZodArray<z.ZodEnum<{
+            events: "events";
+            recovery: "recovery";
+            authentication: "authentication";
+            service_operation: "service_operation";
+            commerce: "commerce";
+        }>>;
+        endpoint_ids: z.ZodArray<z.ZodString>;
+        resource_ids: z.ZodArray<z.ZodString>;
+        operated_by_participant_id: z.ZodString;
+        standard_bindings: z.ZodArray<z.ZodObject<{
+            namespace: z.ZodString;
+            version: z.ZodString;
+            relation: z.ZodEnum<{
+                declares: "declares";
+                describes: "describes";
+                implements: "implements";
+                uses: "uses";
+            }>;
+        }, z.core.$strict>>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        relation_id: z.ZodString;
+        kind: z.ZodEnum<{
+            describes: "describes";
+            authenticates: "authenticates";
+            requires: "requires";
+            alternative_to: "alternative_to";
+            precedes: "precedes";
+        }>;
+        from: z.ZodObject<{
+            node_kind: z.ZodEnum<{
+                resource: "resource";
+                endpoint: "endpoint";
+                interface: "interface";
+                surface_exclusion: "surface_exclusion";
+            }>;
+            node_id: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node_kind: z.ZodEnum<{
+                resource: "resource";
+                endpoint: "endpoint";
+                interface: "interface";
+                surface_exclusion: "surface_exclusion";
+            }>;
+            node_id: z.ZodString;
+        }, z.core.$strict>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    offer_relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        offer_relation_proposal_id: z.ZodString;
+        offer_id: z.ZodString;
+        purpose: z.ZodEnum<{
+            application_path: "application_path";
+            redemption_path: "redemption_path";
+            operating_path: "operating_path";
+        }>;
+        applicable_stages: z.ZodArray<z.ZodEnum<{
+            evaluate: "evaluate";
+            sign_up: "sign_up";
+            pay: "pay";
+            provision: "provision";
+            operate: "operate";
+        }>>;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    surface_exclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        exclusion_id: z.ZodString;
+        role: z.ZodEnum<{
+            policy: "policy";
+            discovery: "discovery";
+            status: "status";
+            pricing: "pricing";
+            eligibility: "eligibility";
+            access: "access";
+            terms: "terms";
+            checkout: "checkout";
+            provisioning: "provisioning";
+            operations: "operations";
+            recovery: "recovery";
+            authentication: "authentication";
+            descriptor: "descriptor";
+            documentation: "documentation";
+        }>;
+        rationale: z.ZodString;
+        source_uris: z.ZodArray<z.ZodURL>;
+    }, z.core.$strict>>>;
+    authority_intent: z.ZodOptional<z.ZodEnum<{
+        entity: "entity";
+        community: "community";
+    }>>;
+    declared_at: z.ZodOptional<z.ZodISODateTime>;
+    base_authoring_file: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        content_digest: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const agentReadinessDraftDiagnosticSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        required: "required";
+        invalid: "invalid";
+        ambiguous_identity: "ambiguous_identity";
+        cross_entity_offer: "cross_entity_offer";
+        base_authoring_mismatch: "base_authoring_mismatch";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>;
+export declare const agentReadinessDeclarationDraftResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"invalid">;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            required: "required";
+            invalid: "invalid";
+            ambiguous_identity: "ambiguous_identity";
+            cross_entity_offer: "cross_entity_offer";
+            base_authoring_mismatch: "base_authoring_mismatch";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"identity_allocation_required">;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            required: "required";
+            invalid: "invalid";
+            ambiguous_identity: "ambiguous_identity";
+            cross_entity_offer: "cross_entity_offer";
+            base_authoring_mismatch: "base_authoring_mismatch";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    diagnostics: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            required: "required";
+            invalid: "invalid";
+            ambiguous_identity: "ambiguous_identity";
+            cross_entity_offer: "cross_entity_offer";
+            base_authoring_mismatch: "base_authoring_mismatch";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    base_release_id: z.ZodString;
+    entity_id: z.ZodString;
+    entity_revision_digest: z.ZodString;
+    status: z.ZodLiteral<"incomplete">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"conflict">;
+    base_release_id: z.ZodString;
+    entity_id: z.ZodOptional<z.ZodString>;
+    entity_revision_digest: z.ZodOptional<z.ZodString>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            required: "required";
+            invalid: "invalid";
+            ambiguous_identity: "ambiguous_identity";
+            cross_entity_offer: "cross_entity_offer";
+            base_authoring_mismatch: "base_authoring_mismatch";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    subject_display: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        product: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        funnel: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    declaration_id: z.ZodString;
+    authoring_file: z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        content_digest: z.ZodString;
+    }, z.core.$strict>;
+    submission: z.ZodObject<{
+        repository: z.ZodLiteral<"sourcey/agent-ready-services">;
+        authority: z.ZodLiteral<"pull_request_merge">;
+    }, z.core.$strict>;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            required: "required";
+            invalid: "invalid";
+            ambiguous_identity: "ambiguous_identity";
+            cross_entity_offer: "cross_entity_offer";
+            base_authoring_mismatch: "base_authoring_mismatch";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    base_release_id: z.ZodString;
+    entity_id: z.ZodString;
+    entity_revision_digest: z.ZodString;
+    status: z.ZodLiteral<"materialized">;
+}, z.core.$strict>], "status">;
+export type AgentReadinessDeclarationDraftRequest = z.infer<typeof agentReadinessDeclarationDraftRequestSchema>;
+export type AgentReadinessDeclarationDraftResult = z.infer<typeof agentReadinessDeclarationDraftResultSchema>;
+//# sourceMappingURL=declaration-acquisition.d.ts.map

package/dist/contracts/agent-readiness/src/declaration-acquisition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration-acquisition.d.ts","sourceRoot":"","sources":["../../../../contracts/agent-readiness/src/declaration-acquisition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,gCAAgC;;;;;;;;;4BAc3C,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;kBAatC,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEnC,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEnC,CAAC;AAEZ,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEpC,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;kBAE3C,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEnC,CAAC;AAEZ,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;kBAExC,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;kBAE3C,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0B7C,CAAC;AAEZ,eAAO,MAAM,mCAAmC;;;;;;;;;;kBAYrC,CAAC;AAQZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAyDrD,CAAC;AAEH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC"}