@papierapi/sdk 0.1.0

package/dist/chunk-JDUUPLUG.js

@@ -0,0 +1,984 @@
+// ../contracts/src/common.ts
+import { z } from "zod";
+var CurrencySchema = z.literal("EUR");
+var IsoDateSchema = z.iso.date();
+var IsoDateTimeSchema = z.iso.datetime({ offset: true });
+var IdempotencyKeySchema = z.string().min(8).max(200).regex(/^[A-Za-z0-9._:-]+$/, "Use only letters, digits, dot, underscore, colon, or dash");
+function prefixedId(prefix) {
+  return z.string().regex(new RegExp(`^${prefix}_[0-9A-HJKMNP-TV-Z]{26}$`));
+}
+var OrganizationIdSchema = prefixedId("org");
+var WorkspaceIdSchema = prefixedId("wsp");
+var SenderProfileIdSchema = prefixedId("snd");
+var DocumentIdSchema = prefixedId("doc");
+var DraftIdSchema = prefixedId("drf");
+var VerificationRunIdSchema = prefixedId("vrf");
+var QuoteIdSchema = prefixedId("quo");
+var ApprovalRequestIdSchema = prefixedId("aprq");
+var ApprovalIdSchema = prefixedId("apr");
+var DirectPaymentIdSchema = prefixedId("dpy");
+var DispatchIdSchema = prefixedId("dsp");
+var EventIdSchema = prefixedId("evt");
+var WebhookEndpointIdSchema = prefixedId("whk");
+var RequestIdSchema = prefixedId("req");
+var MoneySchema = z.object({
+  amount_cents: z.int().min(0).max(1e7),
+  currency: CurrencySchema
+}).strict();
+var MetadataSchema = z.record(z.string().min(1).max(64), z.string().max(500)).refine((value) => Object.keys(value).length <= 20, "At most 20 metadata keys are allowed");
+var NextActionSchema = z.object({
+  action: z.string().min(1).max(64),
+  method: z.enum(["GET", "POST", "PATCH", "DELETE"]).optional(),
+  href: z.string().max(2e3).optional()
+}).strict();
+var PaginationQuerySchema = z.object({
+  cursor: z.string().max(500).optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(25)
+}).strict();
+var PaginatedMetaSchema = z.object({
+  next_cursor: z.string().nullable(),
+  has_more: z.boolean()
+}).strict();
+var Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+var VerificationViolationSchema = z.object({
+  code: z.string().min(1).max(80),
+  field_path: z.string().max(300).optional(),
+  page: z.int().min(1).optional(),
+  rule: z.string().min(1).max(120),
+  message: z.string().min(1).max(1e3),
+  suggested_action: z.string().min(1).max(1e3)
+}).strict();
+var VerificationCheckSchema = z.object({
+  id: z.string().min(1).max(120),
+  version: z.string().min(1).max(40),
+  status: z.enum(["passed", "warning", "failed", "skipped"]),
+  rule: z.string().min(1).max(120),
+  evidence: z.record(z.string(), z.unknown()),
+  violations: z.array(VerificationViolationSchema),
+  duration_ms: z.int().min(0)
+}).strict();
+var VerificationSummarySchema = z.object({
+  status: z.enum(["passed", "warning", "failed"]),
+  checks: z.array(VerificationCheckSchema),
+  verifier_version: z.string()
+}).strict();
+
+// ../contracts/src/dispatch.ts
+import { z as z5 } from "zod";
+
+// ../contracts/src/fax.ts
+import { z as z2 } from "zod";
+var E164Schema = z2.string().regex(/^\+[1-9]\d{7,14}$/);
+var FaxRecipientSchema = z2.object({
+  fax_number_e164: E164Schema,
+  name: z2.string().trim().min(1).max(100).optional(),
+  company: z2.string().trim().min(1).max(100).optional(),
+  recipient_reference: z2.string().max(100).optional()
+}).strict();
+var FaxOptionsSchema = z2.object({
+  max_attempts: z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]).default(2),
+  scheduled_at: IsoDateTimeSchema.describe(
+    "Optional send time between five minutes and 30 days in the future."
+  ).optional(),
+  purpose: z2.enum(["transactional", "contractual", "support", "other"]),
+  consent_reference: z2.string().max(200).optional()
+}).strict();
+var CreateFaxDraftSchema = z2.object({
+  sender_profile_id: SenderProfileIdSchema,
+  recipient: FaxRecipientSchema,
+  document_id: DocumentIdSchema,
+  cover: z2.object({
+    enabled: z2.boolean(),
+    subject: z2.string().max(300).optional(),
+    note: z2.string().max(4e3).optional()
+  }).strict().default({ enabled: false }),
+  options: FaxOptionsSchema,
+  metadata: MetadataSchema.default({})
+}).strict();
+
+// ../contracts/src/letter.ts
+import { z as z3 } from "zod";
+var AddressLineSchema = z3.string().trim().min(1).max(100);
+var GermanStreetRecipientSchema = z3.object({
+  type: z3.literal("street").default("street"),
+  company: AddressLineSchema.optional(),
+  name: AddressLineSchema,
+  attention: AddressLineSchema.optional(),
+  additional_line: AddressLineSchema.optional(),
+  street: AddressLineSchema,
+  house_number: z3.string().trim().min(1).max(20),
+  postal_code: z3.string().regex(/^\d{5}$/),
+  city: AddressLineSchema,
+  country: z3.literal("DE")
+}).strict();
+var GermanPostBoxRecipientSchema = z3.object({
+  type: z3.literal("post_box"),
+  company: AddressLineSchema.optional(),
+  name: AddressLineSchema,
+  attention: AddressLineSchema.optional(),
+  post_box: z3.string().trim().regex(/^\d(?:[ ]?\d){3,9}$/),
+  postal_code: z3.string().regex(/^\d{5}$/),
+  city: AddressLineSchema,
+  country: z3.literal("DE")
+}).strict();
+var GermanPostalRecipientSchema = z3.discriminatedUnion("type", [
+  GermanStreetRecipientSchema,
+  GermanPostBoxRecipientSchema
+]);
+var ParagraphBlockSchema = z3.object({
+  type: z3.literal("paragraph"),
+  text: z3.string().min(1).max(2e4),
+  style: z3.enum(["normal", "emphasis"]).default("normal")
+}).strict();
+var HeadingBlockSchema = z3.object({
+  type: z3.literal("heading"),
+  text: z3.string().min(1).max(300),
+  level: z3.union([z3.literal(1), z3.literal(2)])
+}).strict();
+var ListBlockSchema = z3.object({
+  type: z3.literal("list"),
+  ordered: z3.boolean().default(false),
+  items: z3.array(z3.string().min(1).max(2e3)).min(1).max(100)
+}).strict();
+var TableBlockSchema = z3.object({
+  type: z3.literal("table"),
+  columns: z3.array(z3.string().min(1).max(120)).min(1).max(8),
+  rows: z3.array(z3.array(z3.string().max(1e3)).min(1).max(8)).min(1).max(100)
+}).strict().superRefine((value, ctx) => {
+  value.rows.forEach((row, index) => {
+    if (row.length !== value.columns.length) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Every table row must have the same number of cells as columns",
+        path: ["rows", index]
+      });
+    }
+  });
+});
+var SpacerBlockSchema = z3.object({
+  type: z3.literal("spacer"),
+  millimeters: z3.number().min(1).max(40)
+}).strict();
+var ClosingBlockSchema = z3.object({
+  type: z3.literal("closing"),
+  text: z3.string().min(1).max(2e3)
+}).strict();
+var SignaturePlaceholderSchema = z3.object({
+  type: z3.literal("signature_placeholder"),
+  height_mm: z3.number().min(5).max(40)
+}).strict();
+var LetterBlockSchema = z3.discriminatedUnion("type", [
+  ParagraphBlockSchema,
+  HeadingBlockSchema,
+  ListBlockSchema,
+  TableBlockSchema,
+  SpacerBlockSchema,
+  ClosingBlockSchema,
+  SignaturePlaceholderSchema
+]);
+var StructuredLetterContentSchema = z3.object({
+  locale: z3.enum(["de-DE", "en-DE"]).default("de-DE"),
+  date: IsoDateSchema,
+  reference_lines: z3.array(
+    z3.object({
+      label: z3.string().min(1).max(60),
+      value: z3.string().min(1).max(120)
+    }).strict()
+  ).max(6).optional(),
+  subject: z3.string().trim().min(1).max(300),
+  salutation: z3.string().max(300).optional(),
+  blocks: z3.array(LetterBlockSchema).min(1).max(500),
+  closing: z3.string().max(300).optional(),
+  signatory: z3.string().max(300).optional()
+}).strict();
+var StructuredLetterSourceSchema = z3.object({
+  mode: z3.literal("structured"),
+  content: StructuredLetterContentSchema
+}).strict();
+var RawPdfSourceSchema = z3.object({
+  mode: z3.literal("raw_pdf"),
+  document_id: DocumentIdSchema
+}).strict();
+var LetterSourceSchema = z3.discriminatedUnion("mode", [
+  StructuredLetterSourceSchema,
+  RawPdfSourceSchema
+]);
+var LetterOptionsSchema = z3.object({
+  print: z3.enum(["grayscale", "color"]),
+  duplex: z3.boolean(),
+  service: z3.enum(["standard", "registered_insertion", "registered_signature"]),
+  criticality: z3.enum(["normal", "high"]).default("normal"),
+  layout_profile: z3.enum(["de_business_window_a", "de_business_window_b", "de_business_no_window"]).default("de_business_window_b")
+}).strict();
+var CreateLetterDraftSchema = z3.object({
+  sender_profile_id: SenderProfileIdSchema,
+  recipient: GermanPostalRecipientSchema,
+  source: LetterSourceSchema,
+  attachments: z3.array(z3.object({ document_id: DocumentIdSchema }).strict()).max(20).default([]),
+  options: LetterOptionsSchema,
+  metadata: MetadataSchema.default({})
+}).strict();
+
+// ../contracts/src/platform.ts
+import { z as z4 } from "zod";
+var ProfileLineSchema = z4.string().trim().min(1).max(120);
+var SenderProfilePayloadSchema = z4.object({
+  name: ProfileLineSchema,
+  company: ProfileLineSchema.optional(),
+  street: ProfileLineSchema,
+  house_number: z4.string().trim().min(1).max(20),
+  postal_code: z4.string().regex(/^\d{5}$/),
+  city: ProfileLineSchema,
+  country: z4.literal("DE"),
+  email: z4.email().optional()
+}).strict();
+var SenderProfileUsageSchema = z4.enum(["saved", "one_off"]);
+var CreateSenderProfileSchema = z4.object({
+  name: ProfileLineSchema,
+  sender: SenderProfilePayloadSchema,
+  attest_authorized: z4.literal(true),
+  usage: SenderProfileUsageSchema.default("saved"),
+  make_default: z4.boolean().default(false)
+}).strict().superRefine((value, ctx) => {
+  if (value.usage === "one_off" && value.make_default) {
+    ctx.addIssue({
+      code: "custom",
+      message: "A one-off sender cannot become the default sender",
+      path: ["make_default"]
+    });
+  }
+});
+var UpdateSenderProfileSchema = z4.object({
+  name: ProfileLineSchema,
+  sender: SenderProfilePayloadSchema,
+  attest_authorized: z4.literal(true),
+  make_default: z4.boolean().default(false)
+}).strict();
+var SenderProfileSchema = z4.object({
+  id: SenderProfileIdSchema,
+  name: ProfileLineSchema,
+  status: z4.literal("verified"),
+  usage: SenderProfileUsageSchema,
+  is_default: z4.boolean(),
+  supersedes_sender_profile_id: SenderProfileIdSchema.nullable(),
+  verified_at: IsoDateTimeSchema,
+  archived_at: IsoDateTimeSchema.nullable(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema
+}).strict();
+var SenderProfileVerificationStateSchema = z4.enum(["pending", "verified", "rejected"]);
+var SenderProfileVerificationSchema = z4.object({
+  state: SenderProfileVerificationStateSchema,
+  verified_at: IsoDateTimeSchema.nullable(),
+  expires_at: IsoDateTimeSchema.nullable()
+}).strict();
+var ManagedSenderProfileSchema = SenderProfileSchema.extend({
+  verification: SenderProfileVerificationSchema,
+  is_selectable: z4.boolean()
+}).strict();
+var SelectableSenderProfileSchema = ManagedSenderProfileSchema.extend({
+  verification: SenderProfileVerificationSchema.extend({ state: z4.literal("verified") }).strict(),
+  is_selectable: z4.literal(true)
+}).strict();
+var EditableSenderProfileSchema = ManagedSenderProfileSchema.extend({
+  sender: SenderProfilePayloadSchema
+}).strict();
+var OnboardingAccountTypeSchema = z4.enum(["personal", "organization"]);
+var CompleteOnboardingSchema = z4.object({
+  account_type: OnboardingAccountTypeSchema,
+  organization: z4.object({
+    name: z4.string().trim().min(1).max(160)
+  }).strict().optional(),
+  sender_profile: CreateSenderProfileSchema
+}).strict().superRefine((value, context) => {
+  if (value.sender_profile.usage !== "saved") {
+    context.addIssue({
+      code: "custom",
+      message: "Onboarding requires a saved sender profile",
+      path: ["sender_profile", "usage"]
+    });
+  }
+  if (value.account_type === "organization" && value.organization === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Organization details are required for an organization account",
+      path: ["organization"]
+    });
+  }
+  if (value.account_type === "personal" && value.organization !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Organization details must be omitted for a personal account",
+      path: ["organization"]
+    });
+  }
+});
+var GuestOnboardingSchema = z4.object({
+  email: z4.email().trim().max(254),
+  onboarding: CompleteOnboardingSchema
+}).strict();
+var CompleteOnboardingResultSchema = z4.object({
+  organization: z4.object({
+    id: OrganizationIdSchema,
+    account_type: OnboardingAccountTypeSchema,
+    name: z4.string().min(1).max(160),
+    plan: z4.enum(["developer", "growth", "enterprise"]),
+    status: z4.enum(["active", "suspended", "closed"]),
+    created_at: IsoDateTimeSchema
+  }).strict(),
+  membership: z4.object({ role: z4.literal("owner") }).strict(),
+  sender_profile: z4.object({
+    id: z4.string().regex(/^snd_[0-9A-HJKMNP-TV-Z]{26}$/),
+    name: z4.string().min(1).max(120),
+    status: z4.literal("verified"),
+    verified_at: IsoDateTimeSchema,
+    created_at: IsoDateTimeSchema
+  }).strict()
+}).strict();
+var ApiKeyScopeSchema = z4.enum([
+  "documents:write",
+  "drafts:write",
+  "drafts:read",
+  "approvals:write",
+  "dispatches:write",
+  "dispatches:read",
+  "wallet:read",
+  "wallet:write",
+  "webhooks:write"
+]);
+var CreateApiKeySchema = z4.object({
+  name: z4.string().trim().min(1).max(120),
+  scopes: z4.array(ApiKeyScopeSchema).min(1).max(20),
+  expires_at: z4.iso.datetime({ offset: true }).optional()
+}).strict();
+var CreateApprovalRequestSchema = z4.object({
+  quote_id: z4.string().regex(/^quo_[0-9A-HJKMNP-TV-Z]{26}$/),
+  expires_in_seconds: z4.int().min(300).max(86400).default(3600)
+}).strict();
+var CURRENT_TERMS_VERSION = "2026-07-18";
+var CURRENT_WITHDRAWAL_NOTICE_VERSION = "2026-07-18";
+var ImmediatePerformanceConsentSchema = z4.object({
+  requested_immediate_performance: z4.literal(true),
+  acknowledged_withdrawal_expiry_on_full_performance: z4.literal(true),
+  terms_version: z4.literal(CURRENT_TERMS_VERSION),
+  withdrawal_notice_version: z4.literal(CURRENT_WITHDRAWAL_NOTICE_VERSION)
+}).strict();
+var DecideApprovalSchema = z4.discriminatedUnion("decision", [
+  z4.object({
+    decision: z4.literal("approve"),
+    reason: z4.string().trim().max(1e3).optional(),
+    immediate_performance_consent: ImmediatePerformanceConsentSchema
+  }).strict(),
+  z4.object({
+    decision: z4.literal("reject"),
+    reason: z4.string().trim().max(1e3).optional()
+  }).strict()
+]);
+var ApprovalReferenceSchema = z4.object({
+  approval_request_id: ApprovalRequestIdSchema,
+  approval_id: ApprovalIdSchema.optional()
+}).strict();
+var CreateTopUpSessionSchema = z4.object({
+  amount_cents: z4.int().min(500).max(1e5),
+  success_url: z4.url(),
+  cancel_url: z4.url()
+}).strict();
+var CreateDirectPaymentSessionSchema = z4.object({
+  quote_id: QuoteIdSchema,
+  approval_id: ApprovalIdSchema
+}).strict();
+var DirectPaymentStatusSchema = z4.enum([
+  "pending",
+  "checkout_open",
+  "dispatch_created",
+  "expired",
+  "payment_failed",
+  "refund_required",
+  "refunded"
+]);
+var DirectPaymentSchema = z4.object({
+  id: DirectPaymentIdSchema,
+  status: DirectPaymentStatusSchema,
+  amount_cents: z4.int().min(1).max(1e7),
+  currency: CurrencySchema,
+  expires_at: IsoDateTimeSchema.nullable(),
+  checkout_url: z4.url({ protocol: /^https$/ }).nullable(),
+  dispatch_id: DispatchIdSchema.nullable()
+}).strict();
+var ApprovalPaymentOutcomeSchema = z4.discriminatedUnion("state", [
+  z4.object({
+    state: z4.literal("none"),
+    approval_id: ApprovalIdSchema
+  }).strict(),
+  z4.object({
+    state: z4.literal("wallet_dispatch"),
+    approval_id: ApprovalIdSchema,
+    dispatch_id: DispatchIdSchema,
+    dispatch_status: z4.string().trim().min(1).max(80)
+  }).strict(),
+  z4.object({
+    state: z4.literal("direct_payment"),
+    approval_id: ApprovalIdSchema,
+    direct_payment_id: DirectPaymentIdSchema,
+    direct_payment_status: DirectPaymentStatusSchema,
+    dispatch_id: DispatchIdSchema.nullable()
+  }).strict()
+]);
+var CreateOrganizationSchema = z4.object({
+  id: OrganizationIdSchema.optional(),
+  name: z4.string().trim().min(1).max(160)
+}).strict();
+var WebhookEventSchema = z4.enum([
+  "dispatch.*",
+  "dispatch.funds_reserved",
+  "dispatch.scheduled",
+  "dispatch.submitting",
+  "dispatch.provider_accepted",
+  "dispatch.producing",
+  "dispatch.sending",
+  "dispatch.handed_to_carrier",
+  "dispatch.delivered",
+  "dispatch.failed",
+  "dispatch.returned",
+  "dispatch.cancelled"
+]);
+var CreateWebhookEndpointSchema = z4.object({
+  url: z4.url({ protocol: /^https$/ }),
+  events: z4.array(WebhookEventSchema).min(1).max(20)
+}).strict();
+var McpSendDispatchSchema = z4.object({
+  draft_id: z4.string().regex(/^drf_[0-9A-HJKMNP-TV-Z]{26}$/),
+  quote_id: z4.string().regex(/^quo_[0-9A-HJKMNP-TV-Z]{26}$/),
+  approval_id: ApprovalIdSchema,
+  idempotency_key: IdempotencyKeySchema
+}).strict();
+
+// ../contracts/src/dispatch.ts
+var ChannelSchema = z5.enum(["letter", "fax"]);
+var ProviderNameSchema = z5.enum(["onlinebrief24", "pingen", "faxsuite", "mock"]);
+var DraftStatusSchema = z5.enum([
+  "draft",
+  "validated",
+  "quoted",
+  "awaiting_approval",
+  "approved",
+  "cancelled"
+]);
+var DispatchStatusSchema = z5.enum([
+  "funds_reserved",
+  "submitting",
+  "provider_accepted",
+  "producing",
+  "sending",
+  "handed_to_carrier",
+  "delivered",
+  "failed",
+  "returned",
+  "cancellation_pending",
+  "cancelled"
+]);
+var DraftSchema = z5.object({
+  id: DraftIdSchema,
+  channel: ChannelSchema,
+  status: DraftStatusSchema,
+  content_sha256: Sha256Schema,
+  page_count: z5.int().min(1).max(100),
+  recipient_display: z5.string().min(1).max(200),
+  verification: VerificationSummarySchema,
+  preview_url: z5.url(),
+  preview_expires_at: IsoDateTimeSchema,
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema
+}).strict();
+var ApprovalDraftBaseSchema = DraftSchema.omit({
+  channel: true,
+  recipient_display: true
+});
+var ApprovalLetterDraftSchema = ApprovalDraftBaseSchema.extend({
+  channel: z5.literal("letter"),
+  recipient: GermanPostalRecipientSchema,
+  sender: SenderProfilePayloadSchema,
+  options: LetterOptionsSchema
+}).strict();
+var ApprovalFaxDraftSchema = ApprovalDraftBaseSchema.extend({
+  channel: z5.literal("fax"),
+  recipient: FaxRecipientSchema,
+  sender: SenderProfilePayloadSchema,
+  options: FaxOptionsSchema
+}).strict();
+var ApprovalDraftSchema = z5.discriminatedUnion("channel", [
+  ApprovalLetterDraftSchema,
+  ApprovalFaxDraftSchema
+]);
+var QuoteSchema = z5.object({
+  id: QuoteIdSchema,
+  draft_id: DraftIdSchema,
+  subtotal_cents: z5.int().min(0),
+  vat_cents: z5.int().min(0),
+  total_cents: z5.int().min(0),
+  currency: CurrencySchema,
+  valid_until: IsoDateTimeSchema,
+  assumptions: z5.object({
+    channel: ChannelSchema,
+    country: z5.literal("DE"),
+    pages: z5.int().min(1),
+    service: z5.string()
+  }).strict()
+}).strict();
+var ApprovalQuoteSchema = QuoteSchema.extend({
+  provider: ProviderNameSchema
+}).strict();
+var CreateQuoteSchema = z5.object({}).strict();
+var ApprovalRequestSchema = z5.object({
+  id: ApprovalRequestIdSchema,
+  draft_id: DraftIdSchema,
+  quote_id: QuoteIdSchema,
+  status: z5.enum(["pending", "approved", "rejected", "expired", "stale"]),
+  approval_url: z5.url(),
+  expires_at: IsoDateTimeSchema,
+  created_at: IsoDateTimeSchema
+}).strict();
+var ApprovalReviewSchema = z5.object({
+  approval: ApprovalRequestSchema,
+  decision: z5.discriminatedUnion("status", [
+    z5.object({
+      status: z5.literal("approved"),
+      approval_id: ApprovalIdSchema,
+      decided_at: IsoDateTimeSchema,
+      expires_at: IsoDateTimeSchema
+    }).strict(),
+    z5.object({
+      status: z5.literal("rejected"),
+      approval_id: z5.null(),
+      decided_at: IsoDateTimeSchema,
+      expires_at: z5.null()
+    }).strict()
+  ]).nullable(),
+  draft: ApprovalDraftSchema,
+  quote: ApprovalQuoteSchema,
+  binding_sha256: Sha256Schema
+}).strict();
+var ApprovalDecisionSchema = z5.object({
+  decision: z5.enum(["approve", "reject"]),
+  reason: z5.string().max(1e3).optional()
+}).strict();
+var ApprovalSchema = z5.object({
+  id: ApprovalIdSchema,
+  request_id: ApprovalRequestIdSchema,
+  status: z5.enum(["approved", "rejected"]),
+  actor_type: z5.enum(["human", "policy"]),
+  decided_at: IsoDateTimeSchema
+}).strict();
+var CreateDispatchSchema = z5.object({
+  quote_id: QuoteIdSchema,
+  approval_id: ApprovalIdSchema
+}).strict();
+var DispatchSchema = z5.object({
+  id: DispatchIdSchema,
+  draft_id: DraftIdSchema,
+  status: DispatchStatusSchema,
+  channel: ChannelSchema,
+  amount_cents: z5.int().min(1),
+  currency: CurrencySchema,
+  scheduled_for: IsoDateTimeSchema.nullable(),
+  needs_review: z5.boolean(),
+  terminal_reason: z5.string().max(500).nullable(),
+  created_at: IsoDateTimeSchema,
+  updated_at: IsoDateTimeSchema
+}).strict();
+var DispatchSummaryBaseSchema = z5.object({
+  subject: z5.string().trim().min(1).max(300).nullable()
+});
+var DispatchLetterSummarySchema = DispatchSummaryBaseSchema.extend({
+  channel: z5.literal("letter"),
+  recipient: z5.object({
+    label: z5.string().trim().min(1).max(200),
+    city: z5.string().trim().min(1).max(100)
+  }).strict()
+}).strict();
+var DispatchFaxSummarySchema = DispatchSummaryBaseSchema.extend({
+  channel: z5.literal("fax"),
+  recipient: z5.object({
+    label: z5.string().trim().min(1).max(200).nullable(),
+    fax_number_e164: FaxRecipientSchema.shape.fax_number_e164
+  }).strict()
+}).strict();
+var DispatchSummarySchema = z5.discriminatedUnion("channel", [
+  DispatchLetterSummarySchema,
+  DispatchFaxSummarySchema
+]);
+var DispatchEventSchema = z5.object({
+  id: EventIdSchema,
+  dispatch_id: DispatchIdSchema,
+  sequence: z5.int().min(1),
+  type: z5.string().min(1).max(100),
+  status: DispatchStatusSchema,
+  created_at: IsoDateTimeSchema,
+  evidence: z5.record(z5.string(), z5.unknown()),
+  event_hash: Sha256Schema,
+  previous_hash: Sha256Schema.nullable()
+}).strict();
+var ProofBundleSchema = z5.object({
+  schema_version: z5.literal("2.0"),
+  dispatch_id: DispatchIdSchema,
+  organization_id: OrganizationIdSchema,
+  channel: ChannelSchema,
+  content: z5.object({
+    document_id: DocumentIdSchema,
+    sha256: Sha256Schema
+  }).strict(),
+  recipient: z5.object({
+    fingerprint: Sha256Schema,
+    display: z5.string().min(1).max(200)
+  }).strict(),
+  verification: z5.object({
+    id: VerificationRunIdSchema,
+    verifier_version: z5.string().min(1).max(200),
+    status: z5.enum(["passed", "warning"]),
+    content_sha256: Sha256Schema
+  }).strict(),
+  quote: z5.object({
+    id: QuoteIdSchema,
+    subtotal_cents: z5.int().min(0),
+    vat_cents: z5.int().min(0),
+    total_cents: z5.int().min(0),
+    currency: CurrencySchema,
+    catalog_version: z5.string().min(1).max(200)
+  }).strict(),
+  approval: z5.object({
+    id: ApprovalIdSchema,
+    actor_type: z5.enum(["human", "policy"]),
+    actor_id: z5.string().min(1).max(500),
+    decided_at: IsoDateTimeSchema,
+    binding_hash: Sha256Schema
+  }).strict(),
+  provider: z5.object({
+    name: ProviderNameSchema,
+    acceptance_reference_hash: Sha256Schema,
+    accepted_at: IsoDateTimeSchema
+  }).strict().nullable(),
+  status: z5.object({
+    normalized: DispatchStatusSchema,
+    observed_at: IsoDateTimeSchema
+  }).strict(),
+  event_chain: z5.object({
+    valid: z5.boolean(),
+    checked_events: z5.int().min(0),
+    head: Sha256Schema.nullable()
+  }).strict(),
+  generated_at: IsoDateTimeSchema
+}).strict();
+var ApiEnvelopeSchema = (schema) => z5.object({
+  request_id: RequestIdSchema,
+  data: schema,
+  next_actions: z5.array(NextActionSchema).default([])
+}).strict();
+var ErrorCodeSchema = z5.enum([
+  "SCHEMA_INVALID",
+  "UNAUTHENTICATED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "ADDRESS_INVALID",
+  "FAX_NUMBER_INVALID",
+  "DOCUMENT_UNREADABLE",
+  "PDF_LAYOUT_INVALID",
+  "UNSUPPORTED_OPTION",
+  "VERIFICATION_FAILED",
+  "QUOTE_EXPIRED",
+  "APPROVAL_REQUIRED",
+  "APPROVAL_STALE",
+  "BUDGET_EXCEEDED",
+  "INSUFFICIENT_FUNDS",
+  "IDEMPOTENCY_REQUIRED",
+  "IDEMPOTENCY_CONFLICT",
+  "DISPATCH_NOT_CANCELLABLE",
+  "PROVIDER_UNAVAILABLE",
+  "PROVIDER_REJECTED",
+  "RATE_LIMITED",
+  "INTERNAL_ERROR"
+]);
+var ApiErrorSchema = z5.object({
+  request_id: RequestIdSchema,
+  error: z5.object({
+    code: ErrorCodeSchema,
+    message: z5.string(),
+    retryable: z5.boolean(),
+    field_path: z5.string().optional(),
+    suggested_action: z5.string(),
+    details: z5.record(z5.string(), z5.unknown()).optional()
+  }).strict()
+}).strict();
+
+// ../contracts/src/mcp.ts
+import { z as z6 } from "zod";
+var McpEmptyInputSchema = z6.object({}).strict();
+var McpDraftReferenceSchema = z6.object({ draft_id: DraftIdSchema }).strict();
+var McpDispatchReferenceSchema = z6.object({ dispatch_id: DispatchIdSchema }).strict();
+var McpRequestDispatchApprovalSchema = z6.object({
+  draft_id: DraftIdSchema,
+  ...CreateApprovalRequestSchema.shape
+}).strict();
+var McpListDispatchesInputSchema = z6.object({ limit: z6.number().int().min(1).max(100).default(25) }).strict();
+var WalletBalanceSchema = z6.object({
+  available_cents: z6.int(),
+  reserved_cents: z6.int().min(0),
+  total_cents: z6.int(),
+  currency: z6.literal("EUR")
+}).strict();
+var SenderProfileSummarySchema = SelectableSenderProfileSchema;
+var McpSenderProfilesResultSchema = z6.object({ sender_profiles: z6.array(SenderProfileSummarySchema) }).strict();
+var McpDispatchDetailsSchema = z6.object({
+  dispatch: DispatchSchema,
+  events: z6.array(DispatchEventSchema)
+}).strict();
+var McpDispatchListSchema = z6.object({ dispatches: z6.array(DispatchSchema) }).strict();
+var McpPrepareLetterForReviewSchema = CreateLetterDraftSchema.extend({
+  approval_expires_in_seconds: z6.int().min(300).max(86400).default(3600)
+}).strict();
+var McpPrepareFaxForReviewSchema = CreateFaxDraftSchema.extend({
+  approval_expires_in_seconds: z6.int().min(300).max(86400).default(3600)
+}).strict();
+var McpCoreToolNameSchema = z6.enum([
+  "list_sender_profiles",
+  "prepare_letter_for_review",
+  "prepare_fax_for_review",
+  "get_dispatch",
+  "get_dispatch_proof"
+]);
+var McpReviewPackageSchema = z6.object({
+  draft: DraftSchema,
+  quote: QuoteSchema,
+  approval: ApprovalRequestSchema,
+  human_action_required: z6.literal(true),
+  next_action: z6.object({
+    type: z6.literal("open_approval_url"),
+    url: z6.url(),
+    description: z6.string().min(1).max(500)
+  }).strict()
+}).strict();
+var McpWorkflowGuideSchema = z6.object({
+  version: z6.literal("1.0"),
+  core_tools: z6.array(McpCoreToolNameSchema).min(4).max(5),
+  recommended_letter_tool: z6.literal("prepare_letter_for_review"),
+  recommended_fax_tool: z6.literal("prepare_fax_for_review").optional(),
+  recommended_tracking_tool: z6.literal("get_dispatch"),
+  recommended_proof_tool: z6.literal("get_dispatch_proof"),
+  workflow: z6.array(z6.string().min(1)),
+  safety_invariants: z6.array(z6.string().min(1)),
+  browser_fallback_url: z6.url()
+}).strict();
+
+// ../contracts/src/rest.ts
+import { z as z7 } from "zod";
+var UploadedDocumentResultSchema = z7.object({
+  document: z7.object({
+    id: DocumentIdSchema,
+    sha256: Sha256Schema,
+    byte_size: z7.int().min(1).max(20 * 1024 * 1024),
+    page_count: z7.int().min(1).max(100),
+    created_at: IsoDateTimeSchema
+  }).strict(),
+  verification: VerificationSummarySchema
+}).strict();
+var DispatchListResultSchema = z7.array(DispatchSchema).max(100);
+var DispatchEventListResultSchema = z7.array(DispatchEventSchema);
+function defineRestOperation(operation) {
+  return {
+    ...operation,
+    responseSchema: ApiEnvelopeSchema(operation.dataSchema)
+  };
+}
+var noPathParameters = {};
+var noQueryParameters = {};
+var noRequest = { kind: "none" };
+var PapierApiRestOperations = {
+  uploadDocument: defineRestOperation({
+    operationId: "uploadDocument",
+    method: "POST",
+    path: "/v1/documents",
+    request: { kind: "pdf" },
+    pathParameters: noPathParameters,
+    queryParameters: noQueryParameters,
+    dataSchema: UploadedDocumentResultSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  createLetterDraft: defineRestOperation({
+    operationId: "createLetterDraft",
+    method: "POST",
+    path: "/v1/drafts/letters",
+    request: { kind: "json", schema: CreateLetterDraftSchema },
+    pathParameters: noPathParameters,
+    queryParameters: noQueryParameters,
+    dataSchema: DraftSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  createFaxDraft: defineRestOperation({
+    operationId: "createFaxDraft",
+    method: "POST",
+    path: "/v1/drafts/faxes",
+    request: { kind: "json", schema: CreateFaxDraftSchema },
+    pathParameters: noPathParameters,
+    queryParameters: noQueryParameters,
+    dataSchema: DraftSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  getDraft: defineRestOperation({
+    operationId: "getDraft",
+    method: "GET",
+    path: "/v1/drafts/{draftId}",
+    request: noRequest,
+    pathParameters: { draftId: DraftIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DraftSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  quoteDraft: defineRestOperation({
+    operationId: "quoteDraft",
+    method: "POST",
+    path: "/v1/drafts/{draftId}/quote",
+    request: noRequest,
+    pathParameters: { draftId: DraftIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: QuoteSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  requestApproval: defineRestOperation({
+    operationId: "requestApproval",
+    method: "POST",
+    path: "/v1/drafts/{draftId}/approval-requests",
+    request: { kind: "json", schema: CreateApprovalRequestSchema },
+    pathParameters: { draftId: DraftIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: ApprovalRequestSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  createDispatch: defineRestOperation({
+    operationId: "createDispatch",
+    method: "POST",
+    path: "/v1/drafts/{draftId}/dispatches",
+    request: { kind: "json", schema: CreateDispatchSchema },
+    pathParameters: { draftId: DraftIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DispatchSchema,
+    requiresIdempotencyKey: true,
+    safeToRetry: true
+  }),
+  createDirectPaymentSession: defineRestOperation({
+    operationId: "createDirectPaymentSession",
+    method: "POST",
+    path: "/v1/drafts/{draftId}/direct-payment-sessions",
+    request: { kind: "json", schema: CreateDirectPaymentSessionSchema },
+    pathParameters: { draftId: DraftIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DirectPaymentSchema,
+    requiresIdempotencyKey: true,
+    safeToRetry: true
+  }),
+  getDirectPayment: defineRestOperation({
+    operationId: "getDirectPayment",
+    method: "GET",
+    path: "/v1/direct-payments/{directPaymentId}",
+    request: noRequest,
+    pathParameters: { directPaymentId: DirectPaymentIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DirectPaymentSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  listDispatches: defineRestOperation({
+    operationId: "listDispatches",
+    method: "GET",
+    path: "/v1/dispatches",
+    request: noRequest,
+    pathParameters: noPathParameters,
+    queryParameters: { limit: z7.int().min(1).max(100).default(25) },
+    dataSchema: DispatchListResultSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  getDispatch: defineRestOperation({
+    operationId: "getDispatch",
+    method: "GET",
+    path: "/v1/dispatches/{dispatchId}",
+    request: noRequest,
+    pathParameters: { dispatchId: DispatchIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DispatchSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  getDispatchSummary: defineRestOperation({
+    operationId: "getDispatchSummary",
+    method: "GET",
+    path: "/v1/dispatches/{dispatchId}/summary",
+    request: noRequest,
+    pathParameters: { dispatchId: DispatchIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DispatchSummarySchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  getDispatchEvents: defineRestOperation({
+    operationId: "getDispatchEvents",
+    method: "GET",
+    path: "/v1/dispatches/{dispatchId}/events",
+    request: noRequest,
+    pathParameters: { dispatchId: DispatchIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DispatchEventListResultSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  getDispatchProof: defineRestOperation({
+    operationId: "getDispatchProof",
+    method: "GET",
+    path: "/v1/dispatches/{dispatchId}/proof",
+    request: noRequest,
+    pathParameters: { dispatchId: DispatchIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: ProofBundleSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  }),
+  cancelDispatch: defineRestOperation({
+    operationId: "cancelDispatch",
+    method: "POST",
+    path: "/v1/dispatches/{dispatchId}/cancel",
+    request: noRequest,
+    pathParameters: { dispatchId: DispatchIdSchema },
+    queryParameters: noQueryParameters,
+    dataSchema: DispatchSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: false
+  }),
+  getWallet: defineRestOperation({
+    operationId: "getWallet",
+    method: "GET",
+    path: "/v1/wallet",
+    request: noRequest,
+    pathParameters: noPathParameters,
+    queryParameters: noQueryParameters,
+    dataSchema: WalletBalanceSchema,
+    requiresIdempotencyKey: false,
+    safeToRetry: true
+  })
+};
+
+// src/operations.ts
+var papierApiOperations = PapierApiRestOperations;
+
+export {
+  IdempotencyKeySchema,
+  DraftIdSchema,
+  DirectPaymentIdSchema,
+  DispatchIdSchema,
+  ApiErrorSchema,
+  papierApiOperations
+};
+//# sourceMappingURL=chunk-JDUUPLUG.js.map