@sourcey/catalog-verifier 1.1.18 → 1.1.19

package/dist/contracts/company-verification/src/commercial.d.ts

@@ -0,0 +1,440 @@
+import { z } from "zod";
+export declare const companyVerificationProductCode: "company-human-verification";
+export declare const companyVerificationPrice: {
+    readonly currency: "usd";
+    readonly minor_units: 2900;
+};
+export declare const companyVerificationPriceLookupKey: "company-human-verification-usd-29";
+export declare const companyVerificationPurchaseDisclosureStatement: "Human verification of a company includes publication of a supportable company record with verified status for a legitimate company. Sourcey cannot publish false, unsafe, conflicting, duplicate, or non-existent company claims. Refunds apply when Sourcey cannot deliver the purchased service or misses the review deadline.";
+/** The business days a paid verification is delivered in, counted on Sydney's calendar. */
+export declare const humanVerificationServiceCalendarSchema: z.ZodObject<{
+    time_zone: z.ZodLiteral<"Australia/Sydney">;
+    business_days: z.ZodLiteral<3>;
+    counting: z.ZodLiteral<"next-business-day">;
+    deadline: z.ZodLiteral<"end-of-local-day">;
+    holiday_dates: z.ZodArray<z.ZodISODate>;
+    valid_through: z.ZodISODate;
+    source_url: z.ZodLiteral<"https://www.nsw.gov.au/about-nsw/public-holidays">;
+    source_observed_at: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const companyVerificationServicePolicySchema: z.ZodObject<{
+    policy_contract: z.ZodLiteral<"sourcey.company-verification-service-policy/v1alpha1">;
+    product_code: z.ZodLiteral<"company-human-verification">;
+    price_lookup_key: z.ZodLiteral<"company-human-verification-usd-29">;
+    price: z.ZodObject<{
+        currency: z.ZodLiteral<"usd">;
+        minor_units: z.ZodLiteral<2900>;
+    }, z.core.$strict>;
+    service_calendar: z.ZodObject<{
+        time_zone: z.ZodLiteral<"Australia/Sydney">;
+        business_days: z.ZodLiteral<3>;
+        counting: z.ZodLiteral<"next-business-day">;
+        deadline: z.ZodLiteral<"end-of-local-day">;
+        holiday_dates: z.ZodArray<z.ZodISODate>;
+        valid_through: z.ZodISODate;
+        source_url: z.ZodLiteral<"https://www.nsw.gov.au/about-nsw/public-holidays">;
+        source_observed_at: z.ZodISODateTime;
+    }, z.core.$strict>;
+    material_misrepresentation_refundable: z.ZodLiteral<false>;
+    sla_miss_refundable: z.ZodLiteral<true>;
+    sourcey_error_refundable: z.ZodLiteral<true>;
+    payment_authorizes_human_verification: z.ZodLiteral<true>;
+    payment_changes_truth: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const companyVerificationWorkDefinitionSchema: z.ZodObject<{
+    work_contract: z.ZodLiteral<"sourcey.company-review-work-definition/v1alpha1">;
+    scope: z.ZodLiteral<"one-entity">;
+    passing_results: z.ZodObject<{
+        entity_identity: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            binding: z.ZodLiteral<"identity-epoch">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const companyVerificationPurchaseDisclosureSchema: z.ZodObject<{
+    disclosure_contract: z.ZodLiteral<"sourcey.company-purchase-disclosure/v1alpha1">;
+    statement: z.ZodLiteral<"Human verification of a company includes publication of a supportable company record with verified status for a legitimate company. Sourcey cannot publish false, unsafe, conflicting, duplicate, or non-existent company claims. Refunds apply when Sourcey cannot deliver the purchased service or misses the review deadline.">;
+}, z.core.$strict>;
+export declare const companyVerificationPurchasePreviewSchema: z.ZodObject<{
+    preview_contract: z.ZodLiteral<"sourcey.company-purchase-preview/v1alpha1">;
+    product_code: z.ZodLiteral<"company-human-verification">;
+    purchase_kind: z.ZodLiteral<"one_off">;
+    price_lookup_key: z.ZodLiteral<"company-human-verification-usd-29">;
+    price: z.ZodObject<{
+        currency: z.ZodLiteral<"usd">;
+        minor_units: z.ZodLiteral<2900>;
+    }, z.core.$strict>;
+    work_scope: z.ZodLiteral<"one-entity">;
+    passing_results: z.ZodObject<{
+        entity_identity: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            binding: z.ZodLiteral<"identity-epoch">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    service_level: z.ZodObject<{
+        starts_after: z.ZodLiteral<"settled-payment">;
+        business_days: z.ZodLiteral<3>;
+        time_zone: z.ZodLiteral<"Australia/Sydney">;
+    }, z.core.$strict>;
+    refunds: z.ZodObject<{
+        material_misrepresentation_refundable: z.ZodLiteral<false>;
+        service_level_missed_refundable: z.ZodLiteral<true>;
+        sourcey_error_refundable: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    disclosure: z.ZodLiteral<"Human verification of a company includes publication of a supportable company record with verified status for a legitimate company. Sourcey cannot publish false, unsafe, conflicting, duplicate, or non-existent company claims. Refunds apply when Sourcey cannot deliver the purchased service or misses the review deadline.">;
+    policy_bindings: z.ZodObject<{
+        assurance_method: z.ZodString;
+        purchase_disclosure: z.ZodString;
+        service: z.ZodString;
+    }, z.core.$strict>;
+    preview_digest: z.ZodString;
+}, z.core.$strict>;
+/**
+ * A data repository's pull request adding a company alone (no Offer) below Sourcey's standing bar.
+ * The order serves the pull request's own submission and its exact Entity; the head is where it
+ * was bought. A later head keeps the service while it keeps that Entity, and the person verifies
+ * each head again.
+ */
+export declare const companyVerificationGitPullRequestTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"git_pull_request">;
+    base_release_id: z.ZodString;
+    entity_id: z.ZodString;
+    pull_request: z.ZodObject<{
+        repository_id: z.ZodString;
+        repository: z.ZodString;
+        pull_request_number: z.ZodNumber;
+        submission_id: z.ZodString;
+        head_sha: z.ZodString;
+    }, z.core.$strict>;
+    standing_result: z.ZodObject<{
+        result_contract: z.ZodLiteral<"sourcey.standing-result/v1alpha1">;
+        policy_digest: z.ZodString;
+        evidence_digest: z.ZodString;
+        registrable_domain: z.ZodString;
+        official_source_url: z.ZodURL;
+        route: z.ZodEnum<{
+            correction_required: "correction_required";
+            free_machine_review: "free_machine_review";
+            human_verification_required: "human_verification_required";
+            repair_required: "repair_required";
+            temporarily_unavailable: "temporarily_unavailable";
+        }>;
+        reasons: z.ZodArray<z.ZodString>;
+        evaluated_at: z.ZodISODateTime;
+        expires_at: z.ZodISODateTime;
+        result_digest: z.ZodString;
+    }, z.core.$strict>;
+    authoring_digest: z.ZodString;
+    revisions: z.ZodObject<{
+        entity_revision_digest: z.ZodString;
+    }, z.core.$strict>;
+    labels: z.ZodObject<{
+        company_name: z.ZodString;
+        company_site_url: z.ZodURL;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** The exact pull request head a person verified, and the Entity revision it compiles to. */
+export declare const companyVerificationReviewedRevisionSchema: z.ZodObject<{
+    submission_id: z.ZodString;
+    revision_digest: z.ZodString;
+    head_sha: z.ZodString;
+    entity_revision_digest: z.ZodString;
+}, z.core.$strict>;
+export declare const companyVerificationFundedWorkIntentSchema: z.ZodObject<{
+    product_intent_contract: z.ZodLiteral<"sourcey.company-human-verification-intent/v1alpha1">;
+    verification_case_id: z.ZodString;
+    billing: z.ZodObject<{
+        intent_contract: z.ZodLiteral<"sourcey.funded-work-intent/v1alpha1">;
+        intent_id: z.ZodString;
+        product_code: z.ZodString;
+        purchase_kind: z.ZodLiteral<"one_off">;
+        actor_ref: z.ZodString;
+        owner_work_ref: z.ZodString;
+        owner_payload_digest: z.ZodString;
+        subject: z.ZodObject<{
+            entity_id: z.ZodString;
+            program_id: z.ZodOptional<z.ZodString>;
+            offer_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        base_release_id: z.ZodString;
+        eligibility_digest: z.ZodString;
+        policy_bindings: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            policy_digest: z.ZodString;
+        }, z.core.$strict>>;
+        work_class: z.ZodString;
+        forbidden_effects: z.ZodTuple<[z.ZodLiteral<"admit_without_evidence">, z.ZodLiteral<"alter_facts">, z.ZodLiteral<"alter_ranking">, z.ZodLiteral<"guarantee_outcome">, z.ZodLiteral<"publish_without_authority">], null>;
+        price_lookup_key: z.ZodString;
+        requested_by: z.ZodEnum<{
+            contributor: "contributor";
+            subject: "subject";
+        }>;
+        issued_at: z.ZodISODateTime;
+        expires_at: z.ZodISODateTime;
+        intent_digest: z.ZodString;
+    }, z.core.$strict>;
+    target: z.ZodObject<{
+        kind: z.ZodLiteral<"git_pull_request">;
+        base_release_id: z.ZodString;
+        entity_id: z.ZodString;
+        pull_request: z.ZodObject<{
+            repository_id: z.ZodString;
+            repository: z.ZodString;
+            pull_request_number: z.ZodNumber;
+            submission_id: z.ZodString;
+            head_sha: z.ZodString;
+        }, z.core.$strict>;
+        standing_result: z.ZodObject<{
+            result_contract: z.ZodLiteral<"sourcey.standing-result/v1alpha1">;
+            policy_digest: z.ZodString;
+            evidence_digest: z.ZodString;
+            registrable_domain: z.ZodString;
+            official_source_url: z.ZodURL;
+            route: z.ZodEnum<{
+                correction_required: "correction_required";
+                free_machine_review: "free_machine_review";
+                human_verification_required: "human_verification_required";
+                repair_required: "repair_required";
+                temporarily_unavailable: "temporarily_unavailable";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            evaluated_at: z.ZodISODateTime;
+            expires_at: z.ZodISODateTime;
+            result_digest: z.ZodString;
+        }, z.core.$strict>;
+        authoring_digest: z.ZodString;
+        revisions: z.ZodObject<{
+            entity_revision_digest: z.ZodString;
+        }, z.core.$strict>;
+        labels: z.ZodObject<{
+            company_name: z.ZodString;
+            company_site_url: z.ZodURL;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    purchase_preview_digest: z.ZodString;
+    disclosure_digest: z.ZodString;
+    product_intent_digest: z.ZodString;
+}, z.core.$strict>;
+/** What a person records verifying a company alone: its identity, and nothing about an Offer. */
+export declare const companyVerificationReviewDecisionSchema: z.ZodObject<{
+    entity_identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"passed">;
+        rationale: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        reason_code: z.ZodEnum<{
+            identity_mismatch: "identity_mismatch";
+            identity_unresolved: "identity_unresolved";
+            insufficient_evidence: "insufficient_evidence";
+        }>;
+        rationale: z.ZodString;
+        basis: z.ZodObject<{
+            evidence_event_ids: z.ZodArray<z.ZodString>;
+            observation_ids: z.ZodArray<z.ZodString>;
+            retained_artifact_digests: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "status">;
+}, z.core.$strict>;
+export declare const companyVerificationReviewCompletionReceiptCoreSchema: z.ZodObject<{
+    order_id: z.ZodString;
+    funded_work_intent_id: z.ZodString;
+    funded_work_intent_digest: z.ZodString;
+    verification_case_id: z.ZodString;
+    method_policy_digest: z.ZodString;
+    reviewer_id: z.ZodString;
+    reviewed_at: z.ZodISODateTime;
+    readback_release_id: z.ZodString;
+    work_outcome: z.ZodLiteral<"review_delivered">;
+    entity_identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"passed">;
+        entity_id: z.ZodString;
+        assurance: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            assurance_id: z.ZodString;
+            verified_at: z.ZodISODateTime;
+            identity_epoch_digest: z.ZodString;
+            method_policy_digest: z.ZodString;
+            coverage_policy_digest: z.ZodString;
+            event_id: z.ZodString;
+            receipt_digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"reused">;
+        entity_id: z.ZodString;
+        assurance: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            assurance_id: z.ZodString;
+            verified_at: z.ZodISODateTime;
+            identity_epoch_digest: z.ZodString;
+            method_policy_digest: z.ZodString;
+            coverage_policy_digest: z.ZodString;
+            event_id: z.ZodString;
+            receipt_digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        entity_id: z.ZodString;
+        reason_code: z.ZodEnum<{
+            identity_mismatch: "identity_mismatch";
+            identity_unresolved: "identity_unresolved";
+            insufficient_evidence: "insufficient_evidence";
+        }>;
+        rationale: z.ZodString;
+        basis: z.ZodObject<{
+            evidence_event_ids: z.ZodArray<z.ZodString>;
+            observation_ids: z.ZodArray<z.ZodString>;
+            retained_artifact_digests: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "status">;
+    receipt_contract: z.ZodLiteral<"sourcey.company-review-completion/v1alpha1">;
+    target: z.ZodObject<{
+        kind: z.ZodLiteral<"git_pull_request">;
+        base_release_id: z.ZodString;
+        entity_id: z.ZodString;
+        pull_request: z.ZodObject<{
+            repository_id: z.ZodString;
+            repository: z.ZodString;
+            pull_request_number: z.ZodNumber;
+            submission_id: z.ZodString;
+            head_sha: z.ZodString;
+        }, z.core.$strict>;
+        standing_result: z.ZodObject<{
+            result_contract: z.ZodLiteral<"sourcey.standing-result/v1alpha1">;
+            policy_digest: z.ZodString;
+            evidence_digest: z.ZodString;
+            registrable_domain: z.ZodString;
+            official_source_url: z.ZodURL;
+            route: z.ZodEnum<{
+                correction_required: "correction_required";
+                free_machine_review: "free_machine_review";
+                human_verification_required: "human_verification_required";
+                repair_required: "repair_required";
+                temporarily_unavailable: "temporarily_unavailable";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            evaluated_at: z.ZodISODateTime;
+            expires_at: z.ZodISODateTime;
+            result_digest: z.ZodString;
+        }, z.core.$strict>;
+        authoring_digest: z.ZodString;
+        revisions: z.ZodObject<{
+            entity_revision_digest: z.ZodString;
+        }, z.core.$strict>;
+        labels: z.ZodObject<{
+            company_name: z.ZodString;
+            company_site_url: z.ZodURL;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reviewed_revision: z.ZodObject<{
+        submission_id: z.ZodString;
+        revision_digest: z.ZodString;
+        head_sha: z.ZodString;
+        entity_revision_digest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const companyVerificationReviewCompletionReceiptSchema: z.ZodObject<{
+    order_id: z.ZodString;
+    funded_work_intent_id: z.ZodString;
+    funded_work_intent_digest: z.ZodString;
+    verification_case_id: z.ZodString;
+    method_policy_digest: z.ZodString;
+    reviewer_id: z.ZodString;
+    reviewed_at: z.ZodISODateTime;
+    readback_release_id: z.ZodString;
+    work_outcome: z.ZodLiteral<"review_delivered">;
+    entity_identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"passed">;
+        entity_id: z.ZodString;
+        assurance: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            assurance_id: z.ZodString;
+            verified_at: z.ZodISODateTime;
+            identity_epoch_digest: z.ZodString;
+            method_policy_digest: z.ZodString;
+            coverage_policy_digest: z.ZodString;
+            event_id: z.ZodString;
+            receipt_digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"reused">;
+        entity_id: z.ZodString;
+        assurance: z.ZodObject<{
+            status: z.ZodLiteral<"verified">;
+            assurance_id: z.ZodString;
+            verified_at: z.ZodISODateTime;
+            identity_epoch_digest: z.ZodString;
+            method_policy_digest: z.ZodString;
+            coverage_policy_digest: z.ZodString;
+            event_id: z.ZodString;
+            receipt_digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        entity_id: z.ZodString;
+        reason_code: z.ZodEnum<{
+            identity_mismatch: "identity_mismatch";
+            identity_unresolved: "identity_unresolved";
+            insufficient_evidence: "insufficient_evidence";
+        }>;
+        rationale: z.ZodString;
+        basis: z.ZodObject<{
+            evidence_event_ids: z.ZodArray<z.ZodString>;
+            observation_ids: z.ZodArray<z.ZodString>;
+            retained_artifact_digests: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "status">;
+    receipt_contract: z.ZodLiteral<"sourcey.company-review-completion/v1alpha1">;
+    target: z.ZodObject<{
+        kind: z.ZodLiteral<"git_pull_request">;
+        base_release_id: z.ZodString;
+        entity_id: z.ZodString;
+        pull_request: z.ZodObject<{
+            repository_id: z.ZodString;
+            repository: z.ZodString;
+            pull_request_number: z.ZodNumber;
+            submission_id: z.ZodString;
+            head_sha: z.ZodString;
+        }, z.core.$strict>;
+        standing_result: z.ZodObject<{
+            result_contract: z.ZodLiteral<"sourcey.standing-result/v1alpha1">;
+            policy_digest: z.ZodString;
+            evidence_digest: z.ZodString;
+            registrable_domain: z.ZodString;
+            official_source_url: z.ZodURL;
+            route: z.ZodEnum<{
+                correction_required: "correction_required";
+                free_machine_review: "free_machine_review";
+                human_verification_required: "human_verification_required";
+                repair_required: "repair_required";
+                temporarily_unavailable: "temporarily_unavailable";
+            }>;
+            reasons: z.ZodArray<z.ZodString>;
+            evaluated_at: z.ZodISODateTime;
+            expires_at: z.ZodISODateTime;
+            result_digest: z.ZodString;
+        }, z.core.$strict>;
+        authoring_digest: z.ZodString;
+        revisions: z.ZodObject<{
+            entity_revision_digest: z.ZodString;
+        }, z.core.$strict>;
+        labels: z.ZodObject<{
+            company_name: z.ZodString;
+            company_site_url: z.ZodURL;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reviewed_revision: z.ZodObject<{
+        submission_id: z.ZodString;
+        revision_digest: z.ZodString;
+        head_sha: z.ZodString;
+        entity_revision_digest: z.ZodString;
+    }, z.core.$strict>;
+    receipt_digest: z.ZodString;
+}, z.core.$strict>;
+export type CompanyVerificationServicePolicy = z.infer<typeof companyVerificationServicePolicySchema>;
+export type CompanyVerificationPurchasePreview = z.infer<typeof companyVerificationPurchasePreviewSchema>;
+export type CompanyVerificationGitPullRequestTarget = z.infer<typeof companyVerificationGitPullRequestTargetSchema>;
+export type CompanyVerificationReviewedRevision = z.infer<typeof companyVerificationReviewedRevisionSchema>;
+export type CompanyVerificationFundedWorkIntent = z.infer<typeof companyVerificationFundedWorkIntentSchema>;
+export type CompanyVerificationReviewDecision = z.infer<typeof companyVerificationReviewDecisionSchema>;
+export type CompanyVerificationReviewCompletionReceipt = z.infer<typeof companyVerificationReviewCompletionReceiptSchema>;
+//# sourceMappingURL=commercial.d.ts.map

package/dist/contracts/company-verification/src/commercial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commercial.d.ts","sourceRoot":"","sources":["../../../../contracts/company-verification/src/commercial.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,8BAA8B,EAAG,4BAAqC,CAAC;AACpF,eAAO,MAAM,wBAAwB;aAAK,QAAQ,EAAE,KAAK;aAAE,WAAW,EAAE,IAAK;CAAW,CAAC;AACzF,eAAO,MAAM,iCAAiC,EAAG,mCAA4C,CAAC;AAC9F,eAAO,MAAM,8CAA8C,EACzD,kUAA2U,CAAC;AAE9U,2FAA2F;AAC3F,eAAO,MAAM,sCAAsC;;;;;;;;;kBAuB/C,CAAC;AASL,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;kBAaxC,CAAC;AAEZ,eAAO,MAAM,uCAAuC;;;;;;;;;kBAYzC,CAAC;AAEZ,eAAO,MAAM,2CAA2C;;;kBAK7C,CAAC;AAoCZ,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1C,CAAC;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2B/C,CAAC;AAEZ,6FAA6F;AAC7F,eAAO,MAAM,yCAAyC;;;;;kBAO3C,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsDlD,CAAC;AAEL,iGAAiG;AACjG,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;kBAEzC,CAAC;AAEZ,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgB7D,CAAC;AAEL,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGhD,CAAC;AAEd,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAC;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,wCAAwC,CAChD,CAAC;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC;AACF,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,gDAAgD,CACxD,CAAC"}

package/dist/contracts/company-verification/src/commercial.js

@@ -0,0 +1,231 @@
+import { DIGEST_PATTERN } from "provenry/primitives";
+import { z } from "zod";
+import { ENTITY_ID_PATTERN } from "../../../modules/catalog-primitives/src/index.js";
+import { standingResultSchema } from "../../company-standing/src/index.js";
+import { fundedWorkIntentEnvelopeSchema } from "../../funded-work/src/index.js";
+import { companyIdentityReviewDecisionSchema, completedCompanyReviewCoreSchema } from "./index.js";
+/**
+ * Sourcey's company-only Human Verification: a person verifies one company that falls below the
+ * standing bar, with no Offer, and the verified company is published. Its records are its own
+ * contracts; the Offer product's records keep theirs byte for byte.
+ */
+const digestSchema = z.string().regex(DIGEST_PATTERN);
+const entityIdSchema = z.string().regex(ENTITY_ID_PATTERN);
+const instantSchema = z.iso.datetime({ offset: true });
+export const companyVerificationProductCode = "company-human-verification";
+export const companyVerificationPrice = { currency: "usd", minor_units: 2_900 };
+export const companyVerificationPriceLookupKey = "company-human-verification-usd-29";
+export const companyVerificationPurchaseDisclosureStatement = "Human verification of a company includes publication of a supportable company record with verified status for a legitimate company. Sourcey cannot publish false, unsafe, conflicting, duplicate, or non-existent company claims. Refunds apply when Sourcey cannot deliver the purchased service or misses the review deadline.";
+/** The business days a paid verification is delivered in, counted on Sydney's calendar. */
+export const humanVerificationServiceCalendarSchema = z
+    .object({
+    time_zone: z.literal("Australia/Sydney"),
+    business_days: z.literal(3),
+    counting: z.literal("next-business-day"),
+    deadline: z.literal("end-of-local-day"),
+    holiday_dates: z.array(z.iso.date()).min(1),
+    valid_through: z.iso.date(),
+    source_url: z.literal("https://www.nsw.gov.au/about-nsw/public-holidays"),
+    source_observed_at: instantSchema,
+})
+    .strict()
+    .superRefine((calendar, context) => {
+    if (new Set(calendar.holiday_dates).size !== calendar.holiday_dates.length) {
+        context.addIssue({ code: "custom", message: "Service holidays must be unique." });
+    }
+    if (calendar.holiday_dates.some((date, index) => index > 0 && (calendar.holiday_dates[index - 1] ?? "") >= date)) {
+        context.addIssue({ code: "custom", message: "Service holidays must be sorted." });
+    }
+});
+const companyVerificationPriceSchema = z
+    .object({
+    currency: z.literal(companyVerificationPrice.currency),
+    minor_units: z.literal(companyVerificationPrice.minor_units),
+})
+    .strict();
+export const companyVerificationServicePolicySchema = z
+    .object({
+    policy_contract: z.literal("sourcey.company-verification-service-policy/v1alpha1"),
+    product_code: z.literal(companyVerificationProductCode),
+    price_lookup_key: z.literal(companyVerificationPriceLookupKey),
+    price: companyVerificationPriceSchema,
+    service_calendar: humanVerificationServiceCalendarSchema,
+    material_misrepresentation_refundable: z.literal(false),
+    sla_miss_refundable: z.literal(true),
+    sourcey_error_refundable: z.literal(true),
+    payment_authorizes_human_verification: z.literal(true),
+    payment_changes_truth: z.literal(false),
+})
+    .strict();
+export const companyVerificationWorkDefinitionSchema = z
+    .object({
+    work_contract: z.literal("sourcey.company-review-work-definition/v1alpha1"),
+    scope: z.literal("one-entity"),
+    passing_results: z
+        .object({
+        entity_identity: z
+            .object({ status: z.literal("verified"), binding: z.literal("identity-epoch") })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();
+export const companyVerificationPurchaseDisclosureSchema = z
+    .object({
+    disclosure_contract: z.literal("sourcey.company-purchase-disclosure/v1alpha1"),
+    statement: z.literal(companyVerificationPurchaseDisclosureStatement),
+})
+    .strict();
+const companyVerificationPurchasePreviewCoreSchema = z
+    .object({
+    preview_contract: z.literal("sourcey.company-purchase-preview/v1alpha1"),
+    product_code: z.literal(companyVerificationProductCode),
+    purchase_kind: z.literal("one_off"),
+    price_lookup_key: z.literal(companyVerificationPriceLookupKey),
+    price: companyVerificationPriceSchema,
+    work_scope: z.literal("one-entity"),
+    passing_results: companyVerificationWorkDefinitionSchema.shape.passing_results,
+    service_level: z
+        .object({
+        starts_after: z.literal("settled-payment"),
+        business_days: z.literal(3),
+        time_zone: z.literal("Australia/Sydney"),
+    })
+        .strict(),
+    refunds: z
+        .object({
+        material_misrepresentation_refundable: z.literal(false),
+        service_level_missed_refundable: z.literal(true),
+        sourcey_error_refundable: z.literal(true),
+    })
+        .strict(),
+    disclosure: companyVerificationPurchaseDisclosureSchema.shape.statement,
+    policy_bindings: z
+        .object({
+        assurance_method: digestSchema,
+        purchase_disclosure: digestSchema,
+        service: digestSchema,
+    })
+        .strict(),
+})
+    .strict();
+export const companyVerificationPurchasePreviewSchema = companyVerificationPurchasePreviewCoreSchema
+    .safeExtend({ preview_digest: digestSchema })
+    .strict();
+/**
+ * A data repository's pull request adding a company alone (no Offer) below Sourcey's standing bar.
+ * The order serves the pull request's own submission and its exact Entity; the head is where it
+ * was bought. A later head keeps the service while it keeps that Entity, and the person verifies
+ * each head again.
+ */
+export const companyVerificationGitPullRequestTargetSchema = z
+    .object({
+    kind: z.literal("git_pull_request"),
+    base_release_id: digestSchema,
+    entity_id: entityIdSchema,
+    pull_request: z
+        .object({
+        repository_id: z.string().regex(/^[1-9][0-9]*$/u),
+        repository: z.string().regex(/^[A-Za-z0-9-]+\/[A-Za-z0-9._-]+$/u),
+        pull_request_number: z.number().int().positive(),
+        submission_id: z.string().regex(/^pull_[a-f0-9]{64}$/u),
+        head_sha: z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u),
+    })
+        .strict(),
+    standing_result: standingResultSchema,
+    /** The canonical Entity authoring at the head it was bought at. */
+    authoring_digest: digestSchema,
+    /** The exact Entity revision that head compiles to. */
+    revisions: z.object({ entity_revision_digest: digestSchema }).strict(),
+    /** What that head names, as the person verifying it reads it. */
+    labels: z
+        .object({
+        company_name: z.string().trim().min(1).max(240),
+        company_site_url: z.url({ protocol: /^https$/u }),
+    })
+        .strict(),
+})
+    .strict();
+/** The exact pull request head a person verified, and the Entity revision it compiles to. */
+export const companyVerificationReviewedRevisionSchema = z
+    .object({
+    submission_id: z.string().regex(/^pull_[a-f0-9]{64}$/u),
+    revision_digest: digestSchema,
+    head_sha: z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u),
+    entity_revision_digest: digestSchema,
+})
+    .strict();
+export const companyVerificationFundedWorkIntentSchema = z
+    .object({
+    product_intent_contract: z.literal("sourcey.company-human-verification-intent/v1alpha1"),
+    verification_case_id: z.string().regex(/^hvc_[a-f0-9]{64}$/u),
+    billing: fundedWorkIntentEnvelopeSchema,
+    target: companyVerificationGitPullRequestTargetSchema,
+    purchase_preview_digest: digestSchema,
+    disclosure_digest: digestSchema,
+    product_intent_digest: digestSchema,
+})
+    .strict()
+    .superRefine((intent, context) => {
+    const issue = (path, message) => context.addIssue({ code: "custom", path, message });
+    const { billing, target } = intent;
+    if (billing.product_code !== companyVerificationProductCode) {
+        issue(["billing", "product_code"], "Company verification uses its own product code.");
+    }
+    if (billing.price_lookup_key !== companyVerificationPriceLookupKey) {
+        issue(["billing", "price_lookup_key"], "Company verification uses its own price key.");
+    }
+    if (billing.work_class !== "human-verification") {
+        issue(["billing", "work_class"], "Company verification remains human verification.");
+    }
+    if (target.standing_result.route !== "human_verification_required") {
+        issue(["target", "standing_result", "route"], "A company is verified for payment only when it falls below the standing bar.");
+    }
+    if (billing.eligibility_digest !== target.standing_result.result_digest) {
+        issue(["billing", "eligibility_digest"], "Billing binds the exact standing result.");
+    }
+    const bindings = new Map(billing.policy_bindings.map((b) => [b.role, b.policy_digest]));
+    if (bindings.get("standing") !== target.standing_result.policy_digest) {
+        issue(["billing", "policy_bindings"], "The standing binding matches the standing result.");
+    }
+    if (bindings.get("purchase-disclosure") !== intent.disclosure_digest) {
+        issue(["billing", "policy_bindings"], "The disclosure binding matches the disclosure.");
+    }
+    for (const role of ["assurance-method", "service"]) {
+        if (!bindings.has(role)) {
+            issue(["billing", "policy_bindings"], `The ${role} policy binding is required.`);
+        }
+    }
+    if (billing.owner_work_ref !== intent.verification_case_id ||
+        billing.base_release_id !== target.base_release_id ||
+        billing.subject.entity_id !== target.entity_id ||
+        billing.subject.program_id !== undefined ||
+        billing.subject.offer_id !== undefined) {
+        issue(["billing"], "Billing binds this exact verification case and its company alone.");
+    }
+});
+/** What a person records verifying a company alone: its identity, and nothing about an Offer. */
+export const companyVerificationReviewDecisionSchema = z
+    .object({ entity_identity: companyIdentityReviewDecisionSchema })
+    .strict();
+export const companyVerificationReviewCompletionReceiptCoreSchema = completedCompanyReviewCoreSchema
+    .safeExtend({
+    receipt_contract: z.literal("sourcey.company-review-completion/v1alpha1"),
+    target: companyVerificationGitPullRequestTargetSchema,
+    /** The exact head the person verified, which may follow the one bought. */
+    reviewed_revision: companyVerificationReviewedRevisionSchema,
+})
+    .strict()
+    .superRefine((receipt, context) => {
+    if (receipt.reviewed_revision.submission_id !== receipt.target.pull_request.submission_id) {
+        context.addIssue({
+            code: "custom",
+            path: ["reviewed_revision"],
+            message: "A pull request's completion names exactly the head its person verified.",
+        });
+    }
+});
+export const companyVerificationReviewCompletionReceiptSchema = companyVerificationReviewCompletionReceiptCoreSchema
+    .safeExtend({ receipt_digest: digestSchema })
+    .strict();
+//# sourceMappingURL=commercial.js.map