@timbro/invoices 0.7.0-next.30

package/dist/problem-contract.d.ts

@@ -0,0 +1,265 @@
+import type { ProblemField } from "@timbro/protocol";
+import type { z } from "zod";
+import type { FiscalAdmissionProblem, ProblemBody, PublicProblemCode } from "./generated/types.gen.ts";
+export type ProblemFailure = "authentication" | "validation" | "admission" | "server_processing";
+export type ProblemCode = PublicProblemCode;
+export type FieldProblem = FiscalAdmissionProblem & ProblemField;
+export type { ProblemCatalogEntry } from "./generated/problem-catalog.ts";
+export { PROBLEM_CATALOG } from "./generated/problem-catalog.ts";
+export type { ProblemBody, PublicProblemCode } from "./generated/types.gen.ts";
+export declare const problemBodySchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        affected_fiscal_operation_unsupported: "affected_fiscal_operation_unsupported";
+        already_a_member: "already_a_member";
+        authority_rejected_replacement: "authority_rejected_replacement";
+        certificate_custody_binding_conflict: "certificate_custody_binding_conflict";
+        certificate_custody_binding_not_found: "certificate_custody_binding_not_found";
+        certificate_custody_certificate_version_not_active: "certificate_custody_certificate_version_not_active";
+        certificate_p12_password_invalid: "certificate_p12_password_invalid";
+        commercial_response_decision_conflict: "commercial_response_decision_conflict";
+        commercial_response_motive_invalid: "commercial_response_motive_invalid";
+        correction_target_unsettled: "correction_target_unsettled";
+        credential_revoked: "credential_revoked";
+        custody_certificate_chain_untrusted: "custody_certificate_chain_untrusted";
+        custody_certificate_malformed: "custody_certificate_malformed";
+        custody_certificate_purpose_unsupported: "custody_certificate_purpose_unsupported";
+        custody_certificate_trust_profile_unsupported: "custody_certificate_trust_profile_unsupported";
+        custody_signature_algorithm_unsupported: "custody_signature_algorithm_unsupported";
+        custody_unavailable: "custody_unavailable";
+        delegated_authorization_verifier_forbidden: "delegated_authorization_verifier_forbidden";
+        document_type_not_enabled: "document_type_not_enabled";
+        email_already_registered: "email_already_registered";
+        environment_not_active: "environment_not_active";
+        fiscal_artifact_not_found: "fiscal_artifact_not_found";
+        fiscal_artifact_unavailable: "fiscal_artifact_unavailable";
+        fiscal_artifact_unverified: "fiscal_artifact_unverified";
+        fiscal_delivery_not_found: "fiscal_delivery_not_found";
+        fiscal_delivery_outcome_conflict: "fiscal_delivery_outcome_conflict";
+        fiscal_delivery_unavailable: "fiscal_delivery_unavailable";
+        fiscal_intent_rejected: "fiscal_intent_rejected";
+        fiscal_issuance_blocked: "fiscal_issuance_blocked";
+        fiscal_number_already_used: "fiscal_number_already_used";
+        fiscal_number_authorization_changed: "fiscal_number_authorization_changed";
+        fiscal_number_authorization_source_record_conflict: "fiscal_number_authorization_source_record_conflict";
+        fiscal_operation_not_found: "fiscal_operation_not_found";
+        fiscal_receipt_not_found: "fiscal_receipt_not_found";
+        fiscal_receipt_not_ready: "fiscal_receipt_not_ready";
+        fiscal_receipt_unavailable: "fiscal_receipt_unavailable";
+        hosted_tenant_conflict: "hosted_tenant_conflict";
+        idempotency_key_conflict: "idempotency_key_conflict";
+        insufficient_role: "insufficient_role";
+        internal_error: "internal_error";
+        invalid_certificate_custody_signer_identity: "invalid_certificate_custody_signer_identity";
+        invalid_collection_cursor: "invalid_collection_cursor";
+        invalid_collection_query: "invalid_collection_query";
+        invalid_credential: "invalid_credential";
+        invalid_fiscal_identity: "invalid_fiscal_identity";
+        invalid_idempotency_key: "invalid_idempotency_key";
+        invalid_login: "invalid_login";
+        invalid_replay_scope: "invalid_replay_scope";
+        invalid_request: "invalid_request";
+        invitation_expired: "invitation_expired";
+        invitation_invalid: "invitation_invalid";
+        issuer_not_authorized: "issuer_not_authorized";
+        legal_issuer_already_registered: "legal_issuer_already_registered";
+        legal_issuer_not_found: "legal_issuer_not_found";
+        legal_issuer_profile_incomplete: "legal_issuer_profile_incomplete";
+        malformed_json: "malformed_json";
+        method_not_allowed: "method_not_allowed";
+        missing_idempotency_key: "missing_idempotency_key";
+        onboarding_legal_issuer_identity_conflict: "onboarding_legal_issuer_identity_conflict";
+        organization_not_found: "organization_not_found";
+        organization_slug_taken: "organization_slug_taken";
+        printed_representation_profile_conflict: "printed_representation_profile_conflict";
+        received_document_not_found: "received_document_not_found";
+        request_body_timeout: "request_body_timeout";
+        request_too_large: "request_too_large";
+        route_not_found: "route_not_found";
+        service_role_not_permitted: "service_role_not_permitted";
+        signed_document_schema_invalid: "signed_document_schema_invalid";
+        source_action_conflict: "source_action_conflict";
+        source_command_conflict: "source_command_conflict";
+        source_connection_activation_conflict: "source_connection_activation_conflict";
+        source_connection_activation_verification_rejected: "source_connection_activation_verification_rejected";
+        source_connection_creation_conflict: "source_connection_creation_conflict";
+        source_connection_not_connected: "source_connection_not_connected";
+        source_connection_not_found: "source_connection_not_found";
+        source_content_conflict: "source_content_conflict";
+        source_history_requires_reconciliation: "source_history_requires_reconciliation";
+        source_operation_pending: "source_operation_pending";
+        source_outcome_unknown: "source_outcome_unknown";
+        source_predecessor_conflict: "source_predecessor_conflict";
+        source_provider_authorization_conflict: "source_provider_authorization_conflict";
+        source_provider_authorization_not_found: "source_provider_authorization_not_found";
+        source_provider_authorization_required: "source_provider_authorization_required";
+        source_provider_installation_callback_replayed: "source_provider_installation_callback_replayed";
+        source_provider_installation_disabled: "source_provider_installation_disabled";
+        source_provider_installation_removed: "source_provider_installation_removed";
+        source_provider_installation_request_expired: "source_provider_installation_request_expired";
+        source_provider_installation_request_invalid: "source_provider_installation_request_invalid";
+        source_provider_outcome_unknown: "source_provider_outcome_unknown";
+        source_provider_scope_insufficient: "source_provider_scope_insufficient";
+        source_provider_target_access_removed: "source_provider_target_access_removed";
+        source_provider_throttled: "source_provider_throttled";
+        source_provider_unavailable: "source_provider_unavailable";
+        source_record_already_fiscalized: "source_record_already_fiscalized";
+        source_version_stale: "source_version_stale";
+        unauthenticated: "unauthenticated";
+        unsigned_document_schema_invalid: "unsigned_document_schema_invalid";
+        unsupported_media_type: "unsupported_media_type";
+        unsupported_printed_representation_profile: "unsupported_printed_representation_profile";
+        webhook_destination_not_allowed: "webhook_destination_not_allowed";
+        webhook_endpoint_deleted: "webhook_endpoint_deleted";
+        webhook_endpoint_not_found: "webhook_endpoint_not_found";
+        webhook_endpoint_registration_conflict: "webhook_endpoint_registration_conflict";
+        webhook_endpoint_suspended: "webhook_endpoint_suspended";
+        webhook_event_not_found: "webhook_event_not_found";
+    }>;
+    fiscal_operation_id: z.ZodOptional<z.ZodString>;
+    issuance_blockers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        authorization_cancelled: "authorization_cancelled";
+        authorization_conflicting: "authorization_conflicting";
+        authorization_document_type_mismatch: "authorization_document_type_mismatch";
+        authorization_exhausted: "authorization_exhausted";
+        authorization_expired: "authorization_expired";
+        authorization_missing: "authorization_missing";
+        authorization_not_observed_on_effective_date: "authorization_not_observed_on_effective_date";
+        authorization_range_overlap: "authorization_range_overlap";
+        authorization_superseded: "authorization_superseded";
+        authorization_suspended: "authorization_suspended";
+        central_assignment_requires_verified_authorization: "central_assignment_requires_verified_authorization";
+        document_type_not_recognized: "document_type_not_recognized";
+        fiscal_number_before_verified_floor: "fiscal_number_before_verified_floor";
+        fiscal_number_capacity_exhausted: "fiscal_number_capacity_exhausted";
+        fiscal_number_outside_authorized_range: "fiscal_number_outside_authorized_range";
+        invalid_fiscal_number: "invalid_fiscal_number";
+        invalid_request: "invalid_request";
+        invalid_resolved_facts: "invalid_resolved_facts";
+        numbering_mode_not_enabled: "numbering_mode_not_enabled";
+        numbering_verifier_missing: "numbering_verifier_missing";
+        sequence_expiration_mismatch: "sequence_expiration_mismatch";
+        unsupported_protocol: "unsupported_protocol";
+        unsupported_rules_version: "unsupported_rules_version";
+    }>>>;
+    problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    request_id: z.ZodString;
+    status: z.ZodInt;
+    title: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strict>;
+export declare const problemCodeSchema: z.ZodEnum<{
+    affected_fiscal_operation_unsupported: "affected_fiscal_operation_unsupported";
+    already_a_member: "already_a_member";
+    authority_rejected_replacement: "authority_rejected_replacement";
+    certificate_custody_binding_conflict: "certificate_custody_binding_conflict";
+    certificate_custody_binding_not_found: "certificate_custody_binding_not_found";
+    certificate_custody_certificate_version_not_active: "certificate_custody_certificate_version_not_active";
+    certificate_p12_password_invalid: "certificate_p12_password_invalid";
+    commercial_response_decision_conflict: "commercial_response_decision_conflict";
+    commercial_response_motive_invalid: "commercial_response_motive_invalid";
+    correction_target_unsettled: "correction_target_unsettled";
+    credential_revoked: "credential_revoked";
+    custody_certificate_chain_untrusted: "custody_certificate_chain_untrusted";
+    custody_certificate_malformed: "custody_certificate_malformed";
+    custody_certificate_purpose_unsupported: "custody_certificate_purpose_unsupported";
+    custody_certificate_trust_profile_unsupported: "custody_certificate_trust_profile_unsupported";
+    custody_signature_algorithm_unsupported: "custody_signature_algorithm_unsupported";
+    custody_unavailable: "custody_unavailable";
+    delegated_authorization_verifier_forbidden: "delegated_authorization_verifier_forbidden";
+    document_type_not_enabled: "document_type_not_enabled";
+    email_already_registered: "email_already_registered";
+    environment_not_active: "environment_not_active";
+    fiscal_artifact_not_found: "fiscal_artifact_not_found";
+    fiscal_artifact_unavailable: "fiscal_artifact_unavailable";
+    fiscal_artifact_unverified: "fiscal_artifact_unverified";
+    fiscal_delivery_not_found: "fiscal_delivery_not_found";
+    fiscal_delivery_outcome_conflict: "fiscal_delivery_outcome_conflict";
+    fiscal_delivery_unavailable: "fiscal_delivery_unavailable";
+    fiscal_intent_rejected: "fiscal_intent_rejected";
+    fiscal_issuance_blocked: "fiscal_issuance_blocked";
+    fiscal_number_already_used: "fiscal_number_already_used";
+    fiscal_number_authorization_changed: "fiscal_number_authorization_changed";
+    fiscal_number_authorization_source_record_conflict: "fiscal_number_authorization_source_record_conflict";
+    fiscal_operation_not_found: "fiscal_operation_not_found";
+    fiscal_receipt_not_found: "fiscal_receipt_not_found";
+    fiscal_receipt_not_ready: "fiscal_receipt_not_ready";
+    fiscal_receipt_unavailable: "fiscal_receipt_unavailable";
+    hosted_tenant_conflict: "hosted_tenant_conflict";
+    idempotency_key_conflict: "idempotency_key_conflict";
+    insufficient_role: "insufficient_role";
+    internal_error: "internal_error";
+    invalid_certificate_custody_signer_identity: "invalid_certificate_custody_signer_identity";
+    invalid_collection_cursor: "invalid_collection_cursor";
+    invalid_collection_query: "invalid_collection_query";
+    invalid_credential: "invalid_credential";
+    invalid_fiscal_identity: "invalid_fiscal_identity";
+    invalid_idempotency_key: "invalid_idempotency_key";
+    invalid_login: "invalid_login";
+    invalid_replay_scope: "invalid_replay_scope";
+    invalid_request: "invalid_request";
+    invitation_expired: "invitation_expired";
+    invitation_invalid: "invitation_invalid";
+    issuer_not_authorized: "issuer_not_authorized";
+    legal_issuer_already_registered: "legal_issuer_already_registered";
+    legal_issuer_not_found: "legal_issuer_not_found";
+    legal_issuer_profile_incomplete: "legal_issuer_profile_incomplete";
+    malformed_json: "malformed_json";
+    method_not_allowed: "method_not_allowed";
+    missing_idempotency_key: "missing_idempotency_key";
+    onboarding_legal_issuer_identity_conflict: "onboarding_legal_issuer_identity_conflict";
+    organization_not_found: "organization_not_found";
+    organization_slug_taken: "organization_slug_taken";
+    printed_representation_profile_conflict: "printed_representation_profile_conflict";
+    received_document_not_found: "received_document_not_found";
+    request_body_timeout: "request_body_timeout";
+    request_too_large: "request_too_large";
+    route_not_found: "route_not_found";
+    service_role_not_permitted: "service_role_not_permitted";
+    signed_document_schema_invalid: "signed_document_schema_invalid";
+    source_action_conflict: "source_action_conflict";
+    source_command_conflict: "source_command_conflict";
+    source_connection_activation_conflict: "source_connection_activation_conflict";
+    source_connection_activation_verification_rejected: "source_connection_activation_verification_rejected";
+    source_connection_creation_conflict: "source_connection_creation_conflict";
+    source_connection_not_connected: "source_connection_not_connected";
+    source_connection_not_found: "source_connection_not_found";
+    source_content_conflict: "source_content_conflict";
+    source_history_requires_reconciliation: "source_history_requires_reconciliation";
+    source_operation_pending: "source_operation_pending";
+    source_outcome_unknown: "source_outcome_unknown";
+    source_predecessor_conflict: "source_predecessor_conflict";
+    source_provider_authorization_conflict: "source_provider_authorization_conflict";
+    source_provider_authorization_not_found: "source_provider_authorization_not_found";
+    source_provider_authorization_required: "source_provider_authorization_required";
+    source_provider_installation_callback_replayed: "source_provider_installation_callback_replayed";
+    source_provider_installation_disabled: "source_provider_installation_disabled";
+    source_provider_installation_removed: "source_provider_installation_removed";
+    source_provider_installation_request_expired: "source_provider_installation_request_expired";
+    source_provider_installation_request_invalid: "source_provider_installation_request_invalid";
+    source_provider_outcome_unknown: "source_provider_outcome_unknown";
+    source_provider_scope_insufficient: "source_provider_scope_insufficient";
+    source_provider_target_access_removed: "source_provider_target_access_removed";
+    source_provider_throttled: "source_provider_throttled";
+    source_provider_unavailable: "source_provider_unavailable";
+    source_record_already_fiscalized: "source_record_already_fiscalized";
+    source_version_stale: "source_version_stale";
+    unauthenticated: "unauthenticated";
+    unsigned_document_schema_invalid: "unsigned_document_schema_invalid";
+    unsupported_media_type: "unsupported_media_type";
+    unsupported_printed_representation_profile: "unsupported_printed_representation_profile";
+    webhook_destination_not_allowed: "webhook_destination_not_allowed";
+    webhook_endpoint_deleted: "webhook_endpoint_deleted";
+    webhook_endpoint_not_found: "webhook_endpoint_not_found";
+    webhook_endpoint_registration_conflict: "webhook_endpoint_registration_conflict";
+    webhook_endpoint_suspended: "webhook_endpoint_suspended";
+    webhook_event_not_found: "webhook_event_not_found";
+}>;
+export { parseProblemFields } from "@timbro/protocol";
+export declare function isProblemCode(candidate: unknown): candidate is PublicProblemCode;
+export declare function classifyProblemStatus(problem: ProblemBody): ProblemFailure;
+export type ParsedProblemBody = z.infer<typeof problemBodySchema>;
+//# sourceMappingURL=problem-contract.d.ts.map

package/dist/problem-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problem-contract.d.ts","sourceRoot":"","sources":["../src/problem-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EACV,sBAAsB,EACtB,WAAW,EACX,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAGlC,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,YAAY,GAAG,WAAW,GAAG,mBAAmB,CAAC;AACjG,MAAM,MAAM,WAAW,GAAG,iBAAiB,CAAC;AAC5C,MAAM,MAAM,YAAY,GAAG,sBAAsB,GAAG,YAAY,CAAC;AACjE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE/E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAe,CAAC;AAC9C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqB,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,wBAAgB,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,iBAAiB,CAEhF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAiB1E;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/problem-contract.js

@@ -0,0 +1,25 @@
+import { zProblemBody, zPublicProblemCode } from "./generated/zod.gen.js";
+// biome-ignore lint/performance/noBarrelFile: This module is the SDK's stable problem-contract entrypoint.
+export { PROBLEM_CATALOG } from "./generated/problem-catalog.js";
+export const problemBodySchema = zProblemBody;
+export const problemCodeSchema = zPublicProblemCode;
+export { parseProblemFields } from "@timbro/protocol";
+export function isProblemCode(candidate) {
+    return zPublicProblemCode.safeParse(candidate).success;
+}
+export function classifyProblemStatus(problem) {
+    if (problem.status === 401) {
+        return "authentication";
+    }
+    if (problem.status >= 500) {
+        return "server_processing";
+    }
+    if (problem.status === 400 ||
+        problem.status === 408 ||
+        problem.status === 413 ||
+        problem.status === 415 ||
+        problem.status === 422) {
+        return "validation";
+    }
+    return "admission";
+}

package/dist/public-case.d.ts

@@ -0,0 +1,15 @@
+/** Converts one snake_case identifier to the public camelCase spelling. */
+type SnakeToCamelCase<Value extends string> = Value extends `${infer Head}_${infer Tail}` ? `${Head}${SnakeToCamelCase<Capitalize<Tail>>}` : Value;
+/**
+ * Projects generated JSON types into the readonly camelCase vocabulary exposed by the task SDK.
+ * Generated bindings remain available from `@timbro/invoices/generated` for wire-level consumers.
+ */
+export type ReadonlyCamelCase<Value> = Value extends readonly unknown[] ? readonly ReadonlyCamelCase<Value[number]>[] : Value extends object ? {
+    readonly [Key in keyof Value as Key extends string ? SnakeToCamelCase<Key> : Key]: ReadonlyCamelCase<Value[Key]>;
+} : Value;
+/** Converts JSON received from the Rust wire contract into a public camelCase value. */
+export declare function toPublicCase(value: unknown): unknown;
+/** Converts one public camelCase JSON value to the generated snake_case wire vocabulary. */
+export declare function toWireCase(value: unknown): unknown;
+export {};
+//# sourceMappingURL=public-case.d.ts.map

package/dist/public-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-case.d.ts","sourceRoot":"","sources":["../src/public-case.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,KAAK,gBAAgB,CAAC,KAAK,SAAS,MAAM,IAAI,KAAK,SAAS,GAAG,MAAM,IAAI,IAAI,MAAM,IAAI,EAAE,GACrF,GAAG,IAAI,GAAG,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,GAC9C,KAAK,CAAC;AAEV;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,IAAI,KAAK,SAAS,SAAS,OAAO,EAAE,GACnE,SAAS,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,GAC3C,KAAK,SAAS,MAAM,GAClB;IACE,QAAQ,EAAE,GAAG,IAAI,MAAM,KAAK,IAAI,GAAG,SAAS,MAAM,GAC9C,gBAAgB,CAAC,GAAG,CAAC,GACrB,GAAG,GAAG,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CACxC,GACD,KAAK,CAAC;AAEZ,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUpD;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUlD"}

package/dist/public-case.js

@@ -0,0 +1,26 @@
+/** Converts JSON received from the Rust wire contract into a public camelCase value. */
+export function toPublicCase(value) {
+    if (Array.isArray(value)) {
+        return value.map(toPublicCase);
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, member]) => [toCamelCase(key), toPublicCase(member)]));
+}
+/** Converts one public camelCase JSON value to the generated snake_case wire vocabulary. */
+export function toWireCase(value) {
+    if (Array.isArray(value)) {
+        return value.map(toWireCase);
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, member]) => [toSnakeCase(key), toWireCase(member)]));
+}
+function toCamelCase(value) {
+    return value.replace(/_([a-z])/gu, (_match, character) => character.toUpperCase());
+}
+function toSnakeCase(value) {
+    return value.replace(/[A-Z]/gu, (character) => `_${character.toLowerCase()}`);
+}

package/dist/received-documents.d.ts

@@ -0,0 +1,35 @@
+import { type ReceivedDocumentPage as GeneratedReceivedDocumentPage, type ReceivedDocumentResource as GeneratedReceivedDocumentResource, type ReceivedDocumentRecoveryFilter, type ReceivedDocumentResponseFilter, type ReceivedDocumentStateFilter } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+import { type ReadonlyCamelCase } from "./public-case.ts";
+export type CommercialResponse = {
+    readonly decision: "accepted";
+} | {
+    readonly decision: "rejected";
+    readonly motive: string;
+};
+export type { ReceivedDocumentRecoveryFilter, ReceivedDocumentResponseFilter, ReceivedDocumentStateFilter, } from "./generated/index.ts";
+export type ReceivedDocumentListCommand = {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly state?: ReceivedDocumentStateFilter;
+    readonly response?: ReceivedDocumentResponseFilter;
+    readonly recovery?: ReceivedDocumentRecoveryFilter;
+    readonly signal?: AbortSignal;
+};
+export type ReceivedDocumentSummary = ReadonlyCamelCase<GeneratedReceivedDocumentPage["data"][number]>;
+export type ReceivedDocumentPage = Omit<ReadonlyCamelCase<GeneratedReceivedDocumentPage>, "data"> & {
+    readonly data: readonly ReceivedDocumentSummary[];
+};
+export type ReceivedDocumentResource = ReadonlyCamelCase<GeneratedReceivedDocumentResource>;
+export type ReceivedDocumentSignedDocumentDownload = {
+    readonly bytes: Uint8Array;
+    readonly byteLength: number;
+    readonly contentSha256: string;
+    readonly mediaType: "application/xml";
+    readonly fiscalReceptionId: string;
+};
+export declare function listReceivedDocumentResources(client: Client, command?: ReceivedDocumentListCommand): Promise<ReceivedDocumentPage>;
+export declare function getReceivedDocumentResource(client: Client, fiscalReceptionId: string, signal: AbortSignal | undefined): Promise<ReceivedDocumentResource>;
+export declare function respondToReceivedDocument(client: Client, fiscalReceptionId: string, responseBody: CommercialResponse, signal: AbortSignal | undefined): Promise<ReceivedDocumentResource>;
+export declare function downloadReceivedDocumentSignedDocument(client: Client, fiscalReceptionId: string, signal: AbortSignal | undefined): Promise<ReceivedDocumentSignedDocumentDownload>;
+//# sourceMappingURL=received-documents.d.ts.map

package/dist/received-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"received-documents.d.ts","sourceRoot":"","sources":["../src/received-documents.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,IAAI,6BAA6B,EAC1D,KAAK,wBAAwB,IAAI,iCAAiC,EAGlE,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EAEjC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAE9D,OAAO,EAAE,KAAK,iBAAiB,EAAgB,MAAM,kBAAkB,CAAC;AAGxE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,YAAY,EACV,8BAA8B,EAC9B,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,2BAA2B,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,8BAA8B,CAAC;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,8BAA8B,CAAC;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CACrD,6BAA6B,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAC9C,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,iBAAiB,CAAC,6BAA6B,CAAC,EAChD,MAAM,CACP,GAAG;IACF,QAAQ,CAAC,IAAI,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACnD,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,CAAC,iCAAiC,CAAC,CAAC;AAE5F,MAAM,MAAM,sCAAsC,GAAG;IACnD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oBAAoB,CAAC,CAgB/B;AAED,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,wBAAwB,CAAC,CAWnC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,wBAAwB,CAAC,CAYnC;AAED,wBAAsB,sCAAsC,CAC1D,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,sCAAsC,CAAC,CA8BjD"}

package/dist/received-documents.js

@@ -0,0 +1,83 @@
+import { createArtifactHeaderReader } from "./artifact-headers.js";
+import { downloadSourceReceivedDocumentSignedXml, getSourceReceivedDocument, listSourceReceivedDocuments, respondToReceivedDocument as respondToReceivedDocumentOperation, } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { toPublicCase } from "./public-case.js";
+import { digestSha256Hex } from "./sha256.js";
+export async function listReceivedDocumentResources(client, command = {}) {
+    const response = await listSourceReceivedDocuments({
+        client,
+        query: {
+            cursor: command.cursor,
+            limit: command.limit,
+            state: command.state,
+            response: command.response,
+            recovery: command.recovery,
+        },
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Received document listing failed");
+    }
+    return toPublicCase(response.body);
+}
+export async function getReceivedDocumentResource(client, fiscalReceptionId, signal) {
+    validateReceptionId(fiscalReceptionId);
+    const response = await getSourceReceivedDocument({
+        client,
+        path: { fiscal_reception_id: fiscalReceptionId },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Received document lookup failed");
+    }
+    return toPublicCase(response.body);
+}
+export async function respondToReceivedDocument(client, fiscalReceptionId, responseBody, signal) {
+    validateReceptionId(fiscalReceptionId);
+    const response = await respondToReceivedDocumentOperation({
+        client,
+        path: { fiscal_reception_id: fiscalReceptionId },
+        body: responseBody,
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Received document response failed");
+    }
+    return toPublicCase(response.body);
+}
+export async function downloadReceivedDocumentSignedDocument(client, fiscalReceptionId, signal) {
+    validateReceptionId(fiscalReceptionId);
+    const response = await downloadSourceReceivedDocumentSignedXml({
+        client,
+        path: { fiscal_reception_id: fiscalReceptionId },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Received document download failed");
+    }
+    if (!(response.body instanceof Uint8Array)) {
+        throw new TypeError("Timbro returned a non-binary received document");
+    }
+    const artifactHeaders = createArtifactHeaderReader(response.headers, "received document");
+    const mediaType = artifactHeaders.required("content-type");
+    if (mediaType !== "application/xml") {
+        throw new TypeError("Timbro returned a received document with the wrong media type");
+    }
+    const contentSha256 = artifactHeaders.digest("timbro-artifact-sha256");
+    if ((await digestSha256Hex(response.body)) !== contentSha256) {
+        throw new TypeError("the received document bytes do not match their SHA-256");
+    }
+    const byteLength = response.body.byteLength;
+    return {
+        bytes: response.body,
+        byteLength,
+        contentSha256,
+        mediaType: "application/xml",
+        fiscalReceptionId,
+    };
+}
+function validateReceptionId(value) {
+    if (value.trim() === "") {
+        throw new TypeError("fiscalReceptionId must not be blank");
+    }
+}

package/dist/sha256.d.ts

@@ -0,0 +1,2 @@
+export declare function digestSha256Hex(bytes: Uint8Array): Promise<string>;
+//# sourceMappingURL=sha256.d.ts.map

package/dist/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["../src/sha256.ts"],"names":[],"mappings":"AAAA,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAKxE"}

package/dist/sha256.js

@@ -0,0 +1,6 @@
+export async function digestSha256Hex(bytes) {
+    const digestInput = new Uint8Array(bytes.byteLength);
+    digestInput.set(bytes);
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", digestInput));
+    return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}

package/dist/signed-document.d.ts

@@ -0,0 +1,15 @@
+import type { Client } from "./generated-operation-client.ts";
+export type SignedDocumentDownload = {
+    readonly artifactId: string;
+    readonly artifactKind: "signed_complete_document";
+    readonly byteLength: number;
+    readonly bytes: Uint8Array;
+    readonly certificateSha256: string;
+    readonly contentSha256: string;
+    readonly createdAt: string;
+    readonly fiscalOperationId: string;
+    readonly mediaType: "application/xml";
+    readonly securityCode: string;
+};
+export declare function downloadSignedDocumentResource(client: Client, fiscalOperationId: string, signal: AbortSignal | undefined): Promise<SignedDocumentDownload>;
+//# sourceMappingURL=signed-document.d.ts.map

package/dist/signed-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signed-document.d.ts","sourceRoot":"","sources":["../src/signed-document.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAM9D,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,0BAA0B,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CAuDjC"}

package/dist/signed-document.js

@@ -0,0 +1,57 @@
+import { createArtifactHeaderReader } from "./artifact-headers.js";
+import { findFiscalArtifact } from "./generated/index.js";
+import { throwGeneratedProblem } from "./generated-problem.js";
+import { digestSha256Hex } from "./sha256.js";
+const RFC3339_MILLISECOND_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+export async function downloadSignedDocumentResource(client, fiscalOperationId, signal) {
+    if (fiscalOperationId.trim() === "") {
+        throw new TypeError("fiscalOperationId must not be blank");
+    }
+    const response = await findFiscalArtifact({
+        client,
+        path: { operation_id: fiscalOperationId, artifact_kind: "signed_complete_document" },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Signed document download failed");
+    }
+    if (!(response.body instanceof Uint8Array)) {
+        throw new TypeError("Timbro returned a non-binary signed document");
+    }
+    const artifactHeaders = createArtifactHeaderReader(response.headers);
+    const mediaType = artifactHeaders.required("content-type");
+    if (mediaType !== "application/xml") {
+        throw new TypeError("Timbro returned a signed document with the wrong media type");
+    }
+    const contentSha256 = artifactHeaders.digest("timbro-artifact-sha256");
+    if ((await digestSha256Hex(response.body)) !== contentSha256) {
+        throw new TypeError("the signed document bytes do not match their SHA-256");
+    }
+    const byteLength = response.body.byteLength;
+    const artifactId = artifactHeaders.uuid("timbro-artifact-id");
+    const returnedOperationId = artifactHeaders.uuid("timbro-fiscal-operation-id");
+    if (returnedOperationId.toLowerCase() !== fiscalOperationId.toLowerCase()) {
+        throw new TypeError("the signed document belongs to another Fiscal operation");
+    }
+    const certificateSha256 = artifactHeaders.digest("timbro-certificate-sha256");
+    const securityCode = artifactHeaders.required("timbro-security-code");
+    if (securityCode.length !== 6) {
+        throw new TypeError("Timbro returned an invalid signed document security code");
+    }
+    const createdAt = artifactHeaders.required("timbro-artifact-created-at");
+    if (!(RFC3339_MILLISECOND_UTC_PATTERN.test(createdAt) && Number.isFinite(Date.parse(createdAt)))) {
+        throw new TypeError("Timbro returned an invalid signed document creation time");
+    }
+    return {
+        artifactId,
+        artifactKind: "signed_complete_document",
+        byteLength,
+        bytes: response.body,
+        certificateSha256,
+        contentSha256,
+        createdAt,
+        fiscalOperationId: returnedOperationId,
+        mediaType: "application/xml",
+        securityCode,
+    };
+}

package/dist/source-command-validation.d.ts

@@ -0,0 +1,3 @@
+import type { FiscalSource } from "./fiscal-operation.ts";
+export declare function validateSource(source: FiscalSource): void;
+//# sourceMappingURL=source-command-validation.d.ts.map

package/dist/source-command-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-command-validation.d.ts","sourceRoot":"","sources":["../src/source-command-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK1D,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAiBzD"}

package/dist/source-command-validation.js

@@ -0,0 +1,14 @@
+const SOURCE_RECORD_MAX_LENGTH = 128;
+const SOURCE_VERSION_MAX_LENGTH = 128;
+export function validateSource(source) {
+    if (source.id.trim() === "" ||
+        source.id !== source.id.trim() ||
+        Array.from(source.id).length > SOURCE_RECORD_MAX_LENGTH) {
+        throw new TypeError("source.id must be 1 to 128 characters without surrounding whitespace");
+    }
+    if (source.version.trim() === "" ||
+        source.version !== source.version.trim() ||
+        Array.from(source.version).length > SOURCE_VERSION_MAX_LENGTH) {
+        throw new TypeError("source.version must be 1 to 128 characters without surrounding whitespace");
+    }
+}

package/dist/source-connection-activation.d.ts

@@ -0,0 +1,18 @@
+import { type CompleteActivationVerificationRequest, type WebhookEventEnvelope } from "./generated/index.ts";
+declare const ACTIVATION_VERIFICATION_EVENT_TYPE = "source_connection.verification_requested";
+type SourceConnectionVerificationRequestEvent = Extract<WebhookEventEnvelope, {
+    readonly type: typeof ACTIVATION_VERIFICATION_EVENT_TYPE;
+}>;
+export type SourceConnectionActivationVerificationInput = {
+    readonly verificationRequestEvent: SourceConnectionVerificationRequestEvent;
+    readonly webhookSecret: string;
+    readonly runtimeProviderTargetId: string;
+    readonly runtimeProviderDeploymentId: string;
+};
+/**
+ * Builds the proof a deployed Source target returns for Timbro's signed activation challenge.
+ * Callers must verify the Webhook signature before passing its parsed event here.
+ */
+export declare function buildSourceConnectionActivationVerification(input: SourceConnectionActivationVerificationInput): CompleteActivationVerificationRequest;
+export {};
+//# sourceMappingURL=source-connection-activation.d.ts.map

package/dist/source-connection-activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-connection-activation.d.ts","sourceRoot":"","sources":["../src/source-connection-activation.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,qCAAqC,EAC1C,KAAK,oBAAoB,EAG1B,MAAM,sBAAsB,CAAC;AAI9B,QAAA,MAAM,kCAAkC,6CAA6C,CAAC;AAGtF,KAAK,wCAAwC,GAAG,OAAO,CACrD,oBAAoB,EACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kCAAkC,CAAA;CAAE,CAC7D,CAAC;AAEF,MAAM,MAAM,2CAA2C,GAAG;IACxD,QAAQ,CAAC,wBAAwB,EAAE,wCAAwC,CAAC;IAC5E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,2CAA2C,GACjD,qCAAqC,CAyBvC"}