@nexia/sdk 0.5.0

package/dist/shell.js

@@ -0,0 +1 @@
+export {};

package/dist/signature.d.ts

@@ -0,0 +1,489 @@
+export type SignatureCapabilityKind = "invitation_channel" | "authentication_method" | "routing_mode";
+export type SignatureCapabilityStatus = "operational" | "unavailable";
+export type SignatureCapabilityUnavailableReason = "sms_transport_unconfigured" | "local_delivery_unavailable" | "local_authentication_unavailable" | "routing_mode_unavailable";
+export type SignatureInvitationChannel = "email" | "sms";
+export type SignatureAuthenticationMethod = "request_password" | "email_otp" | "sms_otp";
+export type SignatureRoutingMode = "parallel" | "sequential";
+/** Closed v1 wire vocabulary mirrored by the PHP document-data contracts. */
+export declare const SIGNATURE_DOCUMENT_DATA_FIELD_TYPES: readonly ["string", "text", "date", "datetime", "boolean", "integer", "decimal", "money", "resource_ref", "object", "list"];
+export type SignatureDocumentDataFieldType = (typeof SIGNATURE_DOCUMENT_DATA_FIELD_TYPES)[number];
+export declare const SIGNATURE_DOCUMENT_DATA_CLASSIFICATIONS: readonly ["public", "internal", "confidential", "restricted"];
+export type SignatureDocumentDataClassification = (typeof SIGNATURE_DOCUMENT_DATA_CLASSIFICATIONS)[number];
+export declare const SIGNATURE_DOCUMENT_DATA_FORMATTERS: readonly ["plain", "date_iso", "date_local", "datetime_local", "boolean_yes_no", "integer", "decimal", "money_with_currency", "resource_label"];
+export type SignatureDocumentDataFormatter = (typeof SIGNATURE_DOCUMENT_DATA_FORMATTERS)[number];
+/** Optional temporal component rendered while the complete source value remains frozen. */
+export type SignatureTemporalDisplayPart = "date" | "time" | "year" | "month" | "day";
+export declare const SIGNATURE_DOCUMENT_DATA_LOOKUP_MODES: readonly ["direct_subject", "derived_ref", "explicit_source_ref", "owner_scoped_query"];
+export type SignatureDocumentDataLookupMode = (typeof SIGNATURE_DOCUMENT_DATA_LOOKUP_MODES)[number];
+export declare const SIGNATURE_DOCUMENT_DATA_STATUSES: readonly ["resolved", "selection_required", "missing", "stale", "unavailable"];
+/** Non-probing public state; internal provider diagnostics are not UI wire data. */
+export type SignatureDocumentDataStatus = (typeof SIGNATURE_DOCUMENT_DATA_STATUSES)[number];
+export type SignatureDocumentDataCardinality = "one" | "many";
+/** Canonical public cross-App reference; it never contains protected values. */
+export interface SignatureDocumentDataResourceRef {
+    app_key: string;
+    resource_key: string;
+    resource_id: string;
+    display: string;
+    href?: string | null;
+}
+export interface SignatureDocumentDataContractDescriptor {
+    data_contract_key: string;
+    data_contract_version: number;
+    field_keys: readonly string[];
+}
+/** Recursive bounded object/list schema supplied as catalog metadata only. */
+export interface SignatureDocumentDataFieldDescriptor {
+    key: string;
+    type: SignatureDocumentDataFieldType;
+    required: boolean;
+    classification: SignatureDocumentDataClassification;
+    formatters: readonly SignatureDocumentDataFormatter[];
+    label_key: string;
+    schema?: readonly SignatureDocumentDataFieldDescriptor[];
+}
+/**
+ * App-published catalog metadata. `synthetic_sample` is synthetic authoring
+ * data and must never be substituted with an actual record response.
+ */
+export interface SignatureDocumentDataSourceDescriptor {
+    app_key: string;
+    source_key: string;
+    source_version: number;
+    /** Optional legacy bridge; new sources should identify their owning Resource. */
+    resource_key?: string;
+    supported_subject_resource_keys: readonly string[];
+    cardinality: SignatureDocumentDataCardinality;
+    lookup_mode: SignatureDocumentDataLookupMode;
+    provided_data_contracts: readonly SignatureDocumentDataContractDescriptor[];
+    fields: readonly SignatureDocumentDataFieldDescriptor[];
+    synthetic_sample: Record<string, unknown>;
+    label_key: string;
+    description_key: string;
+    stable_sort_key?: string;
+    default_source_ref_anchor?: string;
+}
+/** Host-enriched authoring entry with App and Resource display metadata. */
+export interface SignatureDocumentDataSourceCatalogEntry extends SignatureDocumentDataSourceDescriptor {
+    /** Host-normalized model identity; legacy sources fall back to source_key. */
+    resource_key: string;
+    /** App overview label key; legacy or incomplete manifests fall back to display metadata. */
+    app_name: string;
+    resource_label_key: string;
+}
+export interface SignatureDocumentDataSourceCatalog {
+    data: readonly SignatureDocumentDataSourceCatalogEntry[];
+}
+export interface SignatureDocumentDataFieldMapping {
+    source_field: string;
+    request_input_key: string;
+    item_selector?: string | null;
+    formatter?: SignatureDocumentDataFormatter | null;
+    date_part?: SignatureTemporalDisplayPart;
+}
+interface SignatureDocumentDataBindingCommon {
+    alias: string;
+    subject_anchor: string;
+    source_ref_anchor?: string | null;
+    required: boolean;
+    cardinality: SignatureDocumentDataCardinality;
+    min_items: number;
+    max_items: number;
+    field_mappings: readonly SignatureDocumentDataFieldMapping[];
+}
+/** A template binding that names one exact App-published source identity. */
+export interface SignatureDocumentDataFixedSourceBinding extends SignatureDocumentDataBindingCommon {
+    selection_mode: "fixed_source";
+    app_key: string;
+    source_key: string;
+    source_version: number;
+}
+/** A template binding that accepts one operational source for a semantic contract. */
+export interface SignatureDocumentDataCompatibleSourceBinding extends SignatureDocumentDataBindingCommon {
+    selection_mode: "compatible_one";
+    data_contract_key: string;
+    data_contract_version: number;
+}
+export type SignatureDocumentDataBinding = SignatureDocumentDataFixedSourceBinding | SignatureDocumentDataCompatibleSourceBinding;
+/** Safe candidate projection for an explicit source selection UI. */
+export interface SignatureDocumentDataCandidate {
+    resource_ref: SignatureDocumentDataResourceRef;
+    source_revision: string | null;
+    content_hash: string | null;
+    effective_at: string | null;
+}
+/** No resolved protected values are part of this UI state contract. */
+export interface SignatureDocumentDataSourceResolution {
+    alias: string;
+    status: SignatureDocumentDataStatus;
+    candidates: readonly SignatureDocumentDataCandidate[];
+    selected_resource_refs: readonly SignatureDocumentDataResourceRef[];
+    resolved_at: string | null;
+}
+export interface SignatureInvitationCapability {
+    kind: "invitation_channel";
+    key: SignatureInvitationChannel;
+    status: SignatureCapabilityStatus;
+    reason_code: SignatureCapabilityUnavailableReason | null;
+    label_key: string;
+    description_key: string;
+}
+export interface SignatureAuthenticationCapability {
+    kind: "authentication_method";
+    key: SignatureAuthenticationMethod;
+    status: SignatureCapabilityStatus;
+    reason_code: SignatureCapabilityUnavailableReason | null;
+    label_key: string;
+    description_key: string;
+}
+export interface SignatureRoutingCapability {
+    kind: "routing_mode";
+    key: SignatureRoutingMode;
+    status: SignatureCapabilityStatus;
+    reason_code: SignatureCapabilityUnavailableReason | null;
+    label_key: string;
+    description_key: string;
+}
+export type SignatureCapability = SignatureInvitationCapability | SignatureAuthenticationCapability | SignatureRoutingCapability;
+export interface SignatureCapabilityCatalog {
+    data: readonly SignatureCapability[];
+}
+export interface SignatureInvitationChannelSelectorProps {
+    catalog: SignatureCapabilityCatalog | null | undefined;
+    invitationChannel: SignatureInvitationChannel;
+    onChange: (channel: SignatureInvitationChannel) => void;
+    disabled?: boolean;
+    allowedChannels?: readonly SignatureInvitationChannel[];
+    testIdPrefix?: string;
+}
+export interface SignatureAuthenticationMethodSelectorProps {
+    catalog: SignatureCapabilityCatalog | null | undefined;
+    authenticationMethods: readonly SignatureAuthenticationMethod[];
+    onChange: (methods: SignatureAuthenticationMethod[]) => void;
+    disabled?: boolean;
+    allowedMethods?: readonly SignatureAuthenticationMethod[];
+    mandatoryMethods?: readonly SignatureAuthenticationMethod[];
+    testIdPrefix?: string;
+}
+/**
+ * Request-local inputs are frozen from a published template policy. App
+ * packages can render the host editor, but cannot change the template policy
+ * through this surface.
+ */
+export type SignatureRequestPreparationInputKind = "text" | "textarea" | "date" | "select" | "checkbox";
+export type SignatureRequestPreparationInputValueAuthority = "coordinator" | "owner_supplied" | "data_source";
+export interface SignatureRequestPreparationRect {
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SignatureRequestPreparationInputDefinition {
+    key: string;
+    label: string;
+    kind: SignatureRequestPreparationInputKind;
+    required: boolean;
+    default_value: string | boolean | null;
+    constraints: {
+        max_length: number;
+    } | {
+        min: string | null;
+        max: string | null;
+    } | {
+        options: string[];
+    } | Record<string, never>;
+    mapping: {
+        mode: "inline";
+    } | {
+        mode: "overlay";
+        rect: SignatureRequestPreparationRect;
+    };
+    value_authority: SignatureRequestPreparationInputValueAuthority;
+    /** Authoring-only signer-area grouping; this grants no source authority. */
+    signatory_role_key?: string;
+    participant_slot?: number;
+    /** Present only when the published policy gives this input to a data source. */
+    source_mapping?: {
+        source_alias: string;
+        source_field: string;
+        formatter: SignatureDocumentDataFormatter;
+        item_selector: "single" | "all";
+    };
+}
+export interface SignatureRequestPreparationEditPolicy {
+    enabled: boolean;
+    allow_additional_text: boolean;
+    additional_text_limit: {
+        max_count: number;
+        max_length: number;
+    } | null;
+    input_definitions: SignatureRequestPreparationInputDefinition[];
+}
+export type SignatureRequestPreparationStatus = "draft" | "rendering" | "ready" | "submitted" | "superseded" | "cancelled";
+export type SignatureRequestPreparationRenderStatus = "queued" | "rendering" | "failed" | "ready";
+export interface SignatureRequestPreparationTextElement {
+    key: string;
+    text: string;
+    rect: SignatureRequestPreparationRect;
+}
+/** A packaged, reviewed image which may be placed on one request document. */
+export interface SignatureRequestPreparationPlacementImageAsset {
+    id: string;
+    label: string;
+}
+/**
+ * A request-local signer form control. `signatory_role_key` and
+ * `participant_slot` identify the immutable signer assignment; an App never
+ * provides a person identifier through this document surface.
+ */
+export type SignatureRequestPreparationPlacementFormKind = "text" | "checkbox" | "date" | "select" | "signer_name" | "signature" | "signed_at";
+export interface SignatureRequestPreparationPlacementStaticTextElement {
+    key: string;
+    type: "static_text";
+    rect: SignatureRequestPreparationRect;
+    text: string;
+    font_size?: number;
+    alignment?: "left" | "center" | "right";
+    color?: string;
+}
+export interface SignatureRequestPreparationPlacementStaticCheckboxElement {
+    key: string;
+    type: "static_checkbox";
+    rect: SignatureRequestPreparationRect;
+}
+/**
+ * A request-local placement of one descriptor-owned field. Existing template
+ * bindings remain immutable; a catalog source added for this request carries
+ * its validated fixed-source identity in `source_binding`. The value itself
+ * never crosses the frontend placement contract.
+ */
+export interface SignatureRequestPreparationPlacementDataSourceElement {
+    key: string;
+    type: "data_source";
+    rect: SignatureRequestPreparationRect;
+    /** Signer card from which this request-local information field was added. */
+    signatory_role_key?: string;
+    participant_slot?: number;
+    source_alias: string;
+    source_field: string;
+    formatter: SignatureDocumentDataFormatter;
+    item_selector: "single" | "all";
+    /** Supported for SDK date and datetime fields; absence renders the complete value. */
+    date_part?: SignatureTemporalDisplayPart;
+    /** Present when this request adds a catalog source not pre-bound by the template. */
+    source_binding?: {
+        selection_mode: "fixed_source";
+        app_key: string;
+        source_key: string;
+        source_version: number;
+        subject_anchor: string;
+        source_ref_anchor: string | null;
+        required: boolean;
+        cardinality: SignatureDocumentDataCardinality;
+        min_items: number;
+        max_items: number;
+    };
+}
+export interface SignatureRequestPreparationPlacementImageElement {
+    key: string;
+    type: "image";
+    rect: SignatureRequestPreparationRect;
+    /** Only an approved asset identity is persisted, never image bytes or a URL. */
+    asset_id: string;
+}
+export interface SignatureRequestPreparationPlacementFormElement {
+    key: string;
+    type: SignatureRequestPreparationPlacementFormKind;
+    rect: SignatureRequestPreparationRect;
+    signatory_role_key: string;
+    participant_slot: number;
+    required?: boolean;
+    label?: string | null;
+    input_guide?: string | null;
+    default_value?: string | boolean | null;
+    /** Present only when `type` is `select`. */
+    options?: string[];
+    /** Supported for date and signed_at fields; absence renders the complete value. */
+    date_part?: SignatureTemporalDisplayPart;
+}
+/**
+ * The canonical `request_document_elements` transport. It is distinct from a
+ * template's document elements: these records live for one prepared request.
+ */
+export type SignatureRequestPreparationPlacementElement = SignatureRequestPreparationPlacementStaticTextElement | SignatureRequestPreparationPlacementStaticCheckboxElement | SignatureRequestPreparationPlacementDataSourceElement | SignatureRequestPreparationPlacementImageElement | SignatureRequestPreparationPlacementFormElement;
+export interface SignatureRequestPreparationPlacementParticipant {
+    signatory_role_key: string;
+    participant_slot: number;
+    label: string;
+}
+export interface SignatureRequestPreparationDocument {
+    public_id: string;
+    revision: number;
+    checksum: string;
+}
+/**
+ * Safe projection consumed by the request-local editor. It deliberately
+ * excludes template source, routing configuration, and App domain fields.
+ */
+export interface SignatureRequestPreparationEditorPreparation {
+    public_id: string;
+    status: SignatureRequestPreparationStatus;
+    preparation_revision: number;
+    /** Legacy template snapshot; request-time placement no longer depends on it. */
+    request_edit_policy: SignatureRequestPreparationEditPolicy | null;
+    render_status: SignatureRequestPreparationRenderStatus | null;
+    signable_document: SignatureRequestPreparationDocument | null;
+}
+export interface SignatureRequestPreparationExactPreviewPreparation {
+    public_id: string;
+    status: SignatureRequestPreparationStatus;
+    signable_document: SignatureRequestPreparationDocument | null;
+}
+/**
+ * App-neutral host editor for request-local content. The App owns persistence
+ * and passes the frozen preparation state back after each save or render.
+ */
+export interface SignatureRequestPreparationEditorProps {
+    tenantId: string | undefined;
+    preparation: SignatureRequestPreparationEditorPreparation;
+    /** Current ready document shown until the exact request render is ready. */
+    baseDocumentPublicId?: string | null;
+    /** @deprecated Request-input definitions are no longer rendered in this step. */
+    inputs: Record<string, string | boolean | null>;
+    /** @deprecated Legacy `additional_text_elements` fallback. */
+    elements: SignatureRequestPreparationTextElement[];
+    dirty: boolean;
+    saving: boolean;
+    /** Canonical request-local placement payload (`request_document_elements`). */
+    requestDocumentElements?: SignatureRequestPreparationPlacementElement[];
+    /**
+     * Frozen signer fields and data overlays inherited from the published
+     * document. They are shown read-only and are never included in
+     * `onRequestDocumentElementsChange`.
+     */
+    inheritedDocumentElements?: readonly SignatureRequestPreparationPlacementElement[];
+    requestDocumentParticipants?: readonly SignatureRequestPreparationPlacementParticipant[];
+    requestDocumentImageAssets?: readonly SignatureRequestPreparationPlacementImageAsset[];
+    /** Value-free cards for the preparation's explicit cross-App data sources. */
+    dataSources?: readonly SignatureRequestPreparationDataSourceCard[];
+    dataSourcesLoading?: boolean;
+    dataSourcesError?: boolean;
+    onRefreshDataSources?: () => Promise<void> | void;
+    onRefreshDataSource?: (alias: string) => Promise<void> | void;
+    onSelectDataSource?: (alias: string, selectedResourceRefs: readonly SignatureDocumentDataResourceRef[]) => Promise<void> | void;
+    onInputsChange: (inputs: Record<string, string | boolean | null>) => void;
+    onElementsChange: (elements: SignatureRequestPreparationTextElement[]) => void;
+    onRequestDocumentElementsChange?: (elements: SignatureRequestPreparationPlacementElement[]) => void;
+}
+export type SignatureSingleRequestParticipantAssignmentSource = "binding_resolved" | "request_supplied" | "template_fixed";
+/** One authorized identity that an App may offer for a signature role. */
+export interface SignatureSingleRequestParticipantCandidate {
+    key: string;
+    partyPublicId?: string | null;
+    userPublicId?: string | null;
+    displayName: string;
+    invitationAddress: string | null;
+}
+/** App-neutral participant role consumed by Core's single-request dialog. */
+export interface SignatureSingleRequestParticipant {
+    roleKey: string;
+    participantSlot: number;
+    label: string;
+    assignmentSource: SignatureSingleRequestParticipantAssignmentSource;
+    candidates: readonly SignatureSingleRequestParticipantCandidate[];
+    initialCandidateKey?: string | null;
+    candidateLabel?: string;
+    invitationAddressLabel?: string;
+    locale?: string;
+}
+/** Frozen coordinator input returned to the owning App for authorization. */
+export interface SignatureSingleRequestParticipantSubmission {
+    roleKey: string;
+    participantSlot: number;
+    partyPublicId: string | null;
+    userPublicId: string | null;
+    displayName: string;
+    locale: string;
+    invitationChannel: "email";
+    invitationAddress: string;
+    requiredMethods: SignatureAuthenticationMethod[];
+    requestPassword?: string;
+}
+export interface SignatureSingleRequestPreparationReference {
+    publicId: string;
+    revision: number;
+}
+export interface SignatureSingleRequestSubmission {
+    preparation: SignatureSingleRequestPreparationReference;
+    expectedDocument: SignatureRequestPreparationDocument;
+    participants: readonly SignatureSingleRequestParticipantSubmission[];
+    expiresInDays: number;
+}
+/**
+ * Core-owned single-request experience for an App-owned subject. The App
+ * retains authorization and durable handoff state behind the two callbacks.
+ */
+export interface SignatureSingleRequestDialogProps {
+    open: boolean;
+    tenantId: string | undefined;
+    legalEntityPublicId: string | null | undefined;
+    title: string;
+    description?: string;
+    requestLabel: string;
+    /** Current ready source document; never used as a participant identity. */
+    sourceDocumentPublicId: string;
+    participants: readonly SignatureSingleRequestParticipant[];
+    participantsLoading?: boolean;
+    participantsError?: boolean;
+    defaultExpiresInDays?: number;
+    onCreatePreparation: (participants: readonly SignatureSingleRequestParticipantSubmission[]) => Promise<SignatureSingleRequestPreparationReference>;
+    onSubmit: (submission: SignatureSingleRequestSubmission) => Promise<void>;
+    onClose: () => void;
+    onDone: () => void;
+}
+/**
+ * Browser-safe preparation card. It intentionally has only aliases,
+ * provenance references, and status; actual document values remain protected
+ * in the preparation snapshot.
+ */
+export interface SignatureRequestPreparationDataSourceCard {
+    alias: string;
+    /** `unresolved` is the value-free pre-refresh UI state. */
+    status: SignatureDocumentDataStatus | "unresolved";
+    cardinality: SignatureDocumentDataCardinality | null;
+    required: boolean | null;
+    min_items: number | null;
+    max_items: number | null;
+    candidates: readonly {
+        resource_ref: SignatureDocumentDataResourceRef;
+    }[];
+    resolved_items: readonly {
+        resource_ref: SignatureDocumentDataResourceRef;
+    }[];
+}
+/** Placement-only workspace exposed to every App through the frontend host. */
+export interface SignatureRequestPreparationPlacementEditorProps {
+    tenantId: string | undefined;
+    preparation: SignatureRequestPreparationEditorPreparation;
+    dirty: boolean;
+    saving: boolean;
+    elements: SignatureRequestPreparationPlacementElement[];
+    /** Read-only signer fields and data overlays inherited from the published document. */
+    inheritedElements?: readonly SignatureRequestPreparationPlacementElement[];
+    participants: readonly SignatureRequestPreparationPlacementParticipant[];
+    imageAssets?: readonly SignatureRequestPreparationPlacementImageAsset[];
+    onElementsChange: (elements: SignatureRequestPreparationPlacementElement[]) => void;
+}
+/** Read-only exact-PDF review for the same frozen preparation revision. */
+export interface SignatureRequestPreparationExactPreviewProps {
+    tenantId: string | undefined;
+    preparation: SignatureRequestPreparationExactPreviewPreparation;
+}
+/**
+ * Reduces the host response to the complete, stable capability catalog.
+ * Malformed, widened, duplicate, or incomplete responses fail closed.
+ */
+export declare function projectSignatureCapabilityCatalog(value: unknown): SignatureCapabilityCatalog;
+export declare function signatureCapabilityIdentity(kind: SignatureCapabilityKind, key: SignatureInvitationChannel | SignatureAuthenticationMethod | SignatureRoutingMode): string;
+export {};

package/dist/signature.js

@@ -0,0 +1,171 @@
+/** Closed v1 wire vocabulary mirrored by the PHP document-data contracts. */
+export const SIGNATURE_DOCUMENT_DATA_FIELD_TYPES = [
+    "string",
+    "text",
+    "date",
+    "datetime",
+    "boolean",
+    "integer",
+    "decimal",
+    "money",
+    "resource_ref",
+    "object",
+    "list",
+];
+export const SIGNATURE_DOCUMENT_DATA_CLASSIFICATIONS = [
+    "public",
+    "internal",
+    "confidential",
+    "restricted",
+];
+export const SIGNATURE_DOCUMENT_DATA_FORMATTERS = [
+    "plain",
+    "date_iso",
+    "date_local",
+    "datetime_local",
+    "boolean_yes_no",
+    "integer",
+    "decimal",
+    "money_with_currency",
+    "resource_label",
+];
+export const SIGNATURE_DOCUMENT_DATA_LOOKUP_MODES = [
+    "direct_subject",
+    "derived_ref",
+    "explicit_source_ref",
+    "owner_scoped_query",
+];
+export const SIGNATURE_DOCUMENT_DATA_STATUSES = [
+    "resolved",
+    "selection_required",
+    "missing",
+    "stale",
+    "unavailable",
+];
+const KNOWN_SIGNATURE_CAPABILITIES = [
+    {
+        kind: "invitation_channel",
+        key: "email",
+        label_key: "signature.invitation.channel.email",
+        description_key: "signature.invitation.channel.email.description",
+    },
+    {
+        kind: "invitation_channel",
+        key: "sms",
+        label_key: "signature.invitation.channel.sms",
+        description_key: "signature.invitation.channel.sms.description",
+    },
+    {
+        kind: "authentication_method",
+        key: "request_password",
+        label_key: "signature.authentication.method.password",
+        description_key: "signature.authentication.method.password.description",
+    },
+    {
+        kind: "authentication_method",
+        key: "email_otp",
+        label_key: "signature.authentication.method.email_otp",
+        description_key: "signature.authentication.method.email_otp.description",
+    },
+    {
+        kind: "authentication_method",
+        key: "sms_otp",
+        label_key: "signature.authentication.method.sms_otp",
+        description_key: "signature.authentication.method.sms_otp.description",
+    },
+    {
+        kind: "routing_mode",
+        key: "parallel",
+        label_key: "signature.template.routing_mode.parallel",
+        description_key: "signature.template.routing_mode.parallel_help",
+    },
+    {
+        kind: "routing_mode",
+        key: "sequential",
+        label_key: "signature.template.routing_mode.sequential",
+        description_key: "signature.template.routing_mode.sequential_help",
+    },
+];
+/**
+ * Reduces the host response to the complete, stable capability catalog.
+ * Malformed, widened, duplicate, or incomplete responses fail closed.
+ */
+export function projectSignatureCapabilityCatalog(value) {
+    const envelope = asRecord(value);
+    const entries = envelope?.data;
+    if (!Array.isArray(entries) ||
+        entries.length !== KNOWN_SIGNATURE_CAPABILITIES.length) {
+        return unavailableSignatureCapabilityCatalog();
+    }
+    const capabilities = new Map();
+    for (const entry of entries) {
+        const capability = projectSignatureCapability(entry);
+        if (!capability)
+            return unavailableSignatureCapabilityCatalog();
+        const identity = signatureCapabilityIdentity(capability.kind, capability.key);
+        if (capabilities.has(identity)) {
+            return unavailableSignatureCapabilityCatalog();
+        }
+        capabilities.set(identity, capability);
+    }
+    const ordered = KNOWN_SIGNATURE_CAPABILITIES.map((definition) => capabilities.get(signatureCapabilityIdentity(definition.kind, definition.key)));
+    return ordered.some((capability) => capability === undefined)
+        ? unavailableSignatureCapabilityCatalog()
+        : { data: ordered };
+}
+export function signatureCapabilityIdentity(kind, key) {
+    return `${kind}:${key}`;
+}
+function projectSignatureCapability(value) {
+    const entry = asRecord(value);
+    if (!entry)
+        return null;
+    if ((entry.kind !== "invitation_channel" &&
+        entry.kind !== "authentication_method" &&
+        entry.kind !== "routing_mode") ||
+        typeof entry.key !== "string" ||
+        (entry.status !== "operational" && entry.status !== "unavailable") ||
+        typeof entry.label_key !== "string" ||
+        typeof entry.description_key !== "string") {
+        return null;
+    }
+    const definition = KNOWN_SIGNATURE_CAPABILITIES.find((candidate) => candidate.kind === entry.kind && candidate.key === entry.key);
+    if (!definition ||
+        entry.label_key !== definition.label_key ||
+        entry.description_key !== definition.description_key) {
+        return null;
+    }
+    if (entry.status === "operational") {
+        return entry.reason_code === null
+            ? capabilityFromDefinition(definition, entry.status, null)
+            : null;
+    }
+    const reasonCode = unavailableReasonFor(definition);
+    return entry.reason_code === reasonCode
+        ? capabilityFromDefinition(definition, entry.status, reasonCode)
+        : null;
+}
+function unavailableSignatureCapabilityCatalog() {
+    return {
+        data: KNOWN_SIGNATURE_CAPABILITIES.map((definition) => capabilityFromDefinition(definition, "unavailable", unavailableReasonFor(definition))),
+    };
+}
+function capabilityFromDefinition(definition, status, reasonCode) {
+    return { ...definition, status, reason_code: reasonCode };
+}
+function unavailableReasonFor(definition) {
+    if (definition.kind === "routing_mode") {
+        return "routing_mode_unavailable";
+    }
+    if (definition.key === "sms" || definition.key === "sms_otp") {
+        return "sms_transport_unconfigured";
+    }
+    return definition.key === "request_password"
+        ? "local_authentication_unavailable"
+        : "local_delivery_unavailable";
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}