@peable.to/contracts 0.3.0 → 1.0.0

package/dist/esm/resources/tax/assessments.js

@@ -0,0 +1,214 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { expandOnlyQuery, listQuery } from '../../common/params.js';
+import { amount, currency, livemode, nullableString, signedAmount, unixSeconds, } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_OBLIGATION_OUTCOMES, TAX_TYPES } from '../../vocabulary/tax.js';
+import { taxCoverageLimitSchema, taxFacts, taxInstantParam, taxRuleSourceSchema, taxState, } from './shared.js';
+/**
+ * An assessment (`taxasm_…`, ADR 0020): the recorded facts judged against a
+ * VERSIONED rule set at one instant. It stores the version and its exact
+ * inputs, so `replay` can re-run them and show the same answer. Every finding
+ * goes to the review queue for a person to decide; none activates collection.
+ */
+export const taxAssessmentReasonSchema = defineComponent('TaxAssessmentReason', z
+    .object({
+    code: z.string(),
+    message: z.string(),
+    evidence: taxFacts.describe('The facts the reason rests on — amounts, counts, ids. Never personal data.'),
+})
+    .strict());
+/** Net sales measured against a rule's threshold. */
+export const taxAssessmentMeasuredSchema = defineComponent('TaxAssessmentMeasured', z
+    .object({
+    amount: signedAmount.describe('Net sales in `currency`: reversals are netted in.'),
+    currency,
+    transactions: z.number().int().nonnegative(),
+    from: unixSeconds,
+    to: unixSeconds,
+    excluded_currencies: z
+        .array(z.string())
+        .describe('Sales in other currencies: counted nowhere, named here.'),
+})
+    .strict());
+export const taxAssessmentResultSchema = defineComponent('TaxAssessmentResult', z
+    .object({
+    rule: nullableString.describe('The rule applied, or `null` for an unsupported jurisdiction.'),
+    country: nullableString,
+    state: taxState,
+    tax_type: z.enum(TAX_TYPES).nullable(),
+    outcome: z.enum(TAX_OBLIGATION_OUTCOMES),
+    reasons: z.array(taxAssessmentReasonSchema),
+    measured: taxAssessmentMeasuredSchema
+        .nullable()
+        .describe('Net sales measured against the threshold, when the rule has one.'),
+    threshold: z.object({ amount, currency }).strict().nullable(),
+    deadline: z
+        .object({
+        kind: z.literal('registration'),
+        due: unixSeconds,
+        source: taxRuleSourceSchema,
+    })
+        .strict()
+        .nullable()
+        .describe('A deadline the rule itself sets (a Texas permit after crossing).'),
+    coverage_limits: z.array(taxCoverageLimitSchema),
+    review_items: z
+        .array(z.string())
+        .describe('The review items (`taxrev_…`) this result opened or kept open.'),
+})
+    .strict());
+const outcomeCount = z.number().int().nonnegative();
+export const taxAssessmentSchema = defineObject('tax.assessment', 'TaxAssessment', z
+    .object({
+    object: z.literal('tax.assessment'),
+    id: z.string().describe('`taxasm_…`.'),
+    livemode,
+    rule_set_version: z.string(),
+    as_of: unixSeconds.describe('The instant the facts were judged at.'),
+    inputs_digest: z
+        .string()
+        .describe('SHA-256 of the canonical inputs — what a replay is checked against.'),
+    results: z.array(taxAssessmentResultSchema),
+    summary: z
+        .object({
+        registration_declared: outcomeCount,
+        likely_required: outcomeCount,
+        approaching_threshold: outcomeCount,
+        not_indicated: outcomeCount,
+        uncertain: outcomeCount,
+        unsupported: outcomeCount,
+    })
+        .strict()
+        .describe('How many results have each outcome.'),
+    created_by: z.object({ type: z.enum(['user', 'service']), id: nullableString }).strict(),
+    created: unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'tax.assessment',
+            id: 'taxasm_0193b8f2c1a87d3e9f4a',
+            livemode: false,
+            rule_set_version: '2026-11-03.1',
+            as_of: 1793750400,
+            inputs_digest: '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
+            results: [
+                {
+                    rule: 'us_tx_sales_tax',
+                    country: 'US',
+                    state: 'TX',
+                    tax_type: 'sales_tax',
+                    outcome: 'approaching_threshold',
+                    reasons: [
+                        {
+                            code: 'approaching_threshold',
+                            message: 'Texas revenue is at or above 80% of the safe-harbor threshold.',
+                            evidence: { measured_minor: '41000000', threshold_minor: '50000000' },
+                        },
+                    ],
+                    measured: {
+                        amount: '41000000',
+                        currency: 'USD',
+                        transactions: 812,
+                        from: 1762041600,
+                        to: 1793577600,
+                        excluded_currencies: [],
+                    },
+                    threshold: { amount: '50000000', currency: 'USD' },
+                    deadline: null,
+                    coverage_limits: [],
+                    review_items: ['taxrev_0193b8f2c1a87d3e9f4a'],
+                },
+            ],
+            summary: {
+                registration_declared: 0,
+                likely_required: 0,
+                approaching_threshold: 1,
+                not_indicated: 0,
+                uncertain: 0,
+                unsupported: 0,
+            },
+            created_by: { type: 'service', id: 'app_42' },
+            created: 1793750400,
+        },
+    ],
+});
+/** Re-running a stored assessment's inputs through its own rule set version. */
+export const taxAssessmentReplaySchema = defineObject('tax.assessment_replay', 'TaxAssessmentReplay', z
+    .object({
+    object: z.literal('tax.assessment_replay'),
+    assessment: z.string().describe('The assessment replayed (`taxasm_…`).'),
+    rule_set_version: z.string(),
+    inputs_digest: z.string(),
+    matches: z
+        .boolean()
+        .describe('`true` when the replayed results are identical to the stored ones.'),
+    results: z
+        .array(taxAssessmentResultSchema)
+        .describe('A replay opens no review items: every `review_items` is empty.'),
+})
+    .strict());
+export const createTaxAssessmentParams = z
+    .object({
+    as_of: taxInstantParam.optional().describe('Unix seconds; default now. Never in the future.'),
+})
+    .strict();
+export const listTaxAssessmentsQuery = listQuery({});
+export const taxAssessmentRoutes = [
+    defineRoute({
+        operationId: 'listTaxAssessments',
+        method: 'get',
+        path: '/v1/tax/assessments',
+        tag: 'Tax compliance',
+        summary: 'List assessments',
+        auth: 'service',
+        scope: 'payments:read',
+        query: listTaxAssessmentsQuery,
+        response: listOf(taxAssessmentSchema),
+        sdk: 'tax.compliance.listAssessments',
+        expandable: 'tax.assessment',
+    }),
+    defineRoute({
+        operationId: 'createTaxAssessment',
+        method: 'post',
+        path: '/v1/tax/assessments',
+        tag: 'Tax compliance',
+        summary: 'Run an assessment',
+        description: 'Judges the recorded facts against the current rule set, opening review items for what needs a person. Activates nothing.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: createTaxAssessmentParams,
+        response: taxAssessmentSchema,
+        sdk: 'tax.compliance.createAssessment',
+    }),
+    defineRoute({
+        operationId: 'retrieveTaxAssessment',
+        method: 'get',
+        path: '/v1/tax/assessments/{id}',
+        tag: 'Tax compliance',
+        summary: 'Retrieve an assessment',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The assessment (`taxasm_…`).' },
+        query: expandOnlyQuery,
+        response: taxAssessmentSchema,
+        sdk: 'tax.compliance.retrieveAssessment',
+        expandable: 'tax.assessment',
+    }),
+    defineRoute({
+        operationId: 'replayTaxAssessment',
+        method: 'get',
+        path: '/v1/tax/assessments/{id}/replay',
+        tag: 'Tax compliance',
+        summary: 'Replay an assessment',
+        description: "Re-runs the stored inputs through the assessment's own rule set version; `matches` says whether the answer is the same.",
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The assessment (`taxasm_…`).' },
+        response: taxAssessmentReplaySchema,
+        sdk: 'tax.compliance.replayAssessment',
+    }),
+];

package/dist/esm/resources/tax/businessProfile.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { defineObject } from '../../common/objects.js';
+import { metadataUpdateParam } from '../../common/params.js';
+import { livemode, metadata, nullableString, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_CUSTOMER_TYPES, TAX_LEGAL_ENTITY_TYPES, TAX_SUPPLY_TYPES } from '../../vocabulary/tax.js';
+import { complianceCountryParam, complianceStateParam } from './shared.js';
+/**
+ * Peable Tax business compliance (ADR 0020): what a business tells Peable
+ * about itself, what Peable works out from it against a VERSIONED rule set
+ * (an assessment), and what needs a person's decision (the review queue).
+ * Nothing here registers, files or pays anything with a government, and
+ * nothing here turns tax collection on: that is still the owner's registration
+ * plus approval (ADR 0011). The merchant API reads it and may run an
+ * assessment; every onboarding fact and decision is the owner's, in Orbit.
+ */
+/**
+ * The business behind a merchant. Deliberately carries NO government
+ * identifier (company number, EIN): none is evidence of a tax obligation and
+ * none is needed by any rule in the supported set.
+ */
+export const taxBusinessProfileSchema = defineObject('tax.business_profile', 'TaxBusinessProfile', z
+    .object({
+    object: z.literal('tax.business_profile'),
+    livemode,
+    legal_name: nullableString.describe('Read from the tax settings, where editing it returns collection to draft.'),
+    entity_type: z
+        .enum(TAX_LEGAL_ENTITY_TYPES)
+        .describe('`unknown` is an answer: the owner does not know yet.'),
+    incorporation_country: nullableString.describe('ISO 3166-1 alpha-2, or `null` while not given. Never evidence of registration.'),
+    incorporation_state: nullableString,
+    fiscal_year_end_month: z
+        .number()
+        .int()
+        .min(1)
+        .max(12)
+        .nullable()
+        .describe('1–12, the month the fiscal year ends in.'),
+    customer_types: z.enum(TAX_CUSTOMER_TYPES),
+    supply_types: z.array(z.enum(TAX_SUPPLY_TYPES)),
+    missing: z
+        .array(z.string())
+        .describe('What onboarding still lacks before an assessment can be complete: `legal_name`, `entity_type`, `customer_types`, `establishment`, `sales_destinations`.'),
+    metadata,
+    updated_by: nullableString,
+    updated: unixSeconds.nullable(),
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'tax.business_profile',
+            livemode: false,
+            legal_name: 'Example Software SL',
+            entity_type: 'limited_liability_company',
+            incorporation_country: 'ES',
+            incorporation_state: null,
+            fiscal_year_end_month: 12,
+            customer_types: 'both',
+            supply_types: ['software_as_a_service'],
+            missing: [],
+            metadata: {},
+            updated_by: 'user_42',
+            updated: 1793750400,
+        },
+    ],
+});
+/** Orbit's profile update (the owner's); `metadata` is a patch. */
+export const updateTaxBusinessProfileParams = z
+    .object({
+    entity_type: z.enum(TAX_LEGAL_ENTITY_TYPES).optional(),
+    incorporation_country: complianceCountryParam.nullable().optional(),
+    incorporation_state: complianceStateParam.optional(),
+    fiscal_year_end_month: z.number().int().min(1).max(12).nullable().optional(),
+    customer_types: z.enum(TAX_CUSTOMER_TYPES).optional(),
+    supply_types: z
+        .array(z.enum(TAX_SUPPLY_TYPES))
+        .max(TAX_SUPPLY_TYPES.length)
+        .refine((list) => new Set(list).size === list.length, 'supply_types must be distinct')
+        .optional(),
+    metadata: metadataUpdateParam.optional(),
+})
+    .strict();
+export const taxBusinessProfileRoutes = [
+    defineRoute({
+        operationId: 'retrieveTaxBusinessProfile',
+        method: 'get',
+        path: '/v1/tax/business_profile',
+        tag: 'Tax compliance',
+        summary: 'Retrieve the business profile',
+        description: 'Changed by the owner in Orbit; a service credential records no onboarding fact.',
+        auth: 'service',
+        scope: 'payments:read',
+        response: taxBusinessProfileSchema,
+        sdk: 'tax.compliance.retrieveBusinessProfile',
+    }),
+];

package/dist/esm/resources/tax/calculations.js

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { livemode, nullableString, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_BEHAVIORS, TAX_COLLECTIONS } from '../../vocabulary/tax.js';
+import { taxCountry, taxMinorAmount, taxReferenceParam, taxState } from './shared.js';
+/**
+ * A tax calculation (`taxcalc_…`, ADR 0011): a frozen answer. Peable decides
+ * whether a registration covers the customer's evidenced location and asks
+ * the provider for the amount only when one does; the answer is stored exactly
+ * as given and never recomputed.
+ */
+export const taxBreakdownEntrySchema = defineComponent('TaxBreakdownEntry', z
+    .object({
+    country: taxCountry,
+    state: taxState,
+    level: nullableString.describe('The jurisdiction level (`country`, `state`, …).'),
+    display_name: nullableString,
+    tax_type: nullableString.describe('`vat`, `sales_tax`, …; `null` when no tax is imposed.'),
+    rate_percentage: nullableString.describe('Decimal string, e.g. `"20.0"`; `null` when no tax is imposed.'),
+    taxable_amount: taxMinorAmount,
+    amount: taxMinorAmount,
+    inclusive: z.boolean(),
+    taxability_reason: z
+        .string()
+        .describe("The provider's reason, or Peable's own `not_registered` / `product_nontaxable`."),
+})
+    .strict());
+export const taxCalculationLineItemSchema = defineComponent('TaxCalculationLineItem', z
+    .object({
+    reference: z.string(),
+    quantity: z.number().int(),
+    tax_code: z.string(),
+    tax_behavior: z.enum(TAX_BEHAVIORS),
+    amount: taxMinorAmount.describe('As given: includes tax when inclusive.'),
+    amount_tax: taxMinorAmount,
+    amount_net: taxMinorAmount.describe('Excluding tax.'),
+    breakdown: z.array(taxBreakdownEntrySchema),
+})
+    .strict());
+export const taxCalculationSchema = defineObject('tax.calculation', 'TaxCalculation', z
+    .object({
+    object: z.literal('tax.calculation'),
+    id: z.string().describe('`taxcalc_…`.'),
+    currency: z.string().describe('Uppercase ISO 4217.'),
+    collection: z
+        .enum(TAX_COLLECTIONS)
+        .describe('Why the tax is what it is: `collect` (a registration covers the customer and the provider calculated), `not_registered` (none does: zero tax, recorded as such), `nontaxable` (every line used the nontaxable code).'),
+    registration_id: nullableString.describe('The registration (`taxreg_…`) that collects.'),
+    provider: nullableString,
+    provider_calculation_ref: nullableString,
+    customer_location_evidence_id: z.string().describe('`taxloc_…`.'),
+    country: taxCountry,
+    state: taxState,
+    amount_total: taxMinorAmount.describe('What the customer pays.'),
+    amount_net: taxMinorAmount,
+    tax_amount_exclusive: taxMinorAmount,
+    tax_amount_inclusive: taxMinorAmount,
+    line_items: z.array(taxCalculationLineItemSchema),
+    tax_date: unixSeconds,
+    created: unixSeconds,
+    expires_at: unixSeconds,
+    livemode,
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'tax.calculation',
+            id: 'taxcalc_0193b8f2c1a87d3e9f4a',
+            currency: 'EUR',
+            collection: 'collect',
+            registration_id: 'taxreg_0193b8f2c1a87d3e9f4a',
+            provider: 'stripe_tax',
+            provider_calculation_ref: 'taxcalc_1QxYz2AbCdEf',
+            customer_location_evidence_id: 'taxloc_0193b8f2c1a87d3e9f4a',
+            country: 'DE',
+            state: null,
+            amount_total: 1190,
+            amount_net: 1000,
+            tax_amount_exclusive: 190,
+            tax_amount_inclusive: 0,
+            line_items: [
+                {
+                    reference: 'plan_pro_monthly',
+                    quantity: 1,
+                    tax_code: 'txcd_10103001',
+                    tax_behavior: 'exclusive',
+                    amount: 1000,
+                    amount_tax: 190,
+                    amount_net: 1000,
+                    breakdown: [
+                        {
+                            country: 'DE',
+                            state: null,
+                            level: 'country',
+                            display_name: 'VAT',
+                            tax_type: 'vat',
+                            rate_percentage: '19.0',
+                            taxable_amount: 1000,
+                            amount: 190,
+                            inclusive: false,
+                            taxability_reason: 'standard_rated',
+                        },
+                    ],
+                },
+            ],
+            tax_date: 1793750400,
+            created: 1793750400,
+            expires_at: 1793836800,
+            livemode: false,
+        },
+    ],
+});
+export const taxLineItemParams = z
+    .object({
+    reference: z.string().min(1).max(200),
+    amount: z
+        .number()
+        .int()
+        .nonnegative()
+        .safe()
+        .describe('Unit amount × quantity, minor units. Includes tax when inclusive.'),
+    quantity: z.number().int().positive().max(1000000).optional(),
+    tax_code: z
+        .string()
+        .optional()
+        .describe("Defaults to the product's tax code, then the merchant's default."),
+    tax_behavior: z
+        .enum(TAX_BEHAVIORS)
+        .optional()
+        .describe("Defaults to the merchant's default tax behavior."),
+})
+    .strict();
+export const createTaxCalculationParams = z
+    .object({
+    currency: z.string().regex(/^[A-Za-z]{3}$/),
+    customer_location_evidence_id: taxReferenceParam.describe('Sufficient, unexpired evidence (`taxloc_…`).'),
+    line_items: z
+        .array(taxLineItemParams)
+        .min(1)
+        .max(100)
+        .refine((lines) => new Set(lines.map((line) => line.reference)).size === lines.length, 'Line references must be unique'),
+})
+    .strict();
+export const taxCalculationRoutes = [
+    defineRoute({
+        operationId: 'createTaxCalculation',
+        method: 'post',
+        path: '/v1/tax/calculations',
+        tag: 'Tax',
+        summary: 'Calculate tax',
+        description: 'Calculate and freeze. Refused with `tax_settings_not_active` until the owner approves; a covered sale the provider cannot price fails closed (`tax_calculation_unavailable`), never zero.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: createTaxCalculationParams,
+        response: taxCalculationSchema,
+        status: 201,
+        sdk: 'tax.calculations.create',
+    }),
+    defineRoute({
+        operationId: 'retrieveTaxCalculation',
+        method: 'get',
+        path: '/v1/tax/calculations/{id}',
+        tag: 'Tax',
+        summary: 'Retrieve a tax calculation',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The calculation (`taxcalc_…`).' },
+        response: taxCalculationSchema,
+        sdk: 'tax.calculations.retrieve',
+    }),
+];

package/dist/esm/resources/tax/capabilities.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { livemode } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_COMPLIANCE_CAPABILITY_CATEGORIES, TAX_COMPLIANCE_CAPABILITY_STATUSES, } from '../../vocabulary/tax.js';
+/** What Peable Tax compliance can and cannot do, each stated rather than simulated. */
+export const taxComplianceCapabilitySchema = defineComponent('TaxComplianceCapability', z
+    .object({
+    id: z.string(),
+    category: z
+        .enum(TAX_COMPLIANCE_CAPABILITY_CATEGORIES)
+        .describe('VAT/sales tax, corporate income tax and annual company filings are different obligations.'),
+    status: z.enum(TAX_COMPLIANCE_CAPABILITY_STATUSES),
+    reason: z.string(),
+})
+    .strict());
+export const taxComplianceCapabilitiesSchema = defineObject('tax.compliance_capabilities', 'TaxComplianceCapabilities', z
+    .object({
+    object: z.literal('tax.compliance_capabilities'),
+    livemode,
+    rule_set_version: z.string(),
+    supported_rules: z.array(z.string()).describe('The ids of the rules assessed.'),
+    capabilities: z.array(taxComplianceCapabilitySchema),
+})
+    .strict());
+export const taxCapabilityRoutes = [
+    defineRoute({
+        operationId: 'retrieveTaxComplianceCapabilities',
+        method: 'get',
+        path: '/v1/tax/capabilities',
+        tag: 'Tax compliance',
+        summary: 'Retrieve compliance capabilities',
+        description: 'What is available, limited, not available or out of scope — Peable submits, files and pays nothing with any authority.',
+        auth: 'service',
+        scope: 'payments:read',
+        response: taxComplianceCapabilitiesSchema,
+        sdk: 'tax.compliance.retrieveCapabilities',
+    }),
+];

package/dist/esm/resources/tax/codes.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineComponent } from '../../common/objects.js';
+import { defineRoute } from '../../route.js';
+/** A product tax code Peable accepts (`txcd_…`, Stripe Tax's ids). */
+export const taxCodeSchema = defineComponent('TaxCode', z
+    .object({
+    id: z.string().describe('`txcd_…`.'),
+    name: z.string(),
+    description: z.string(),
+})
+    .strict(), {
+    examples: [
+        {
+            id: 'txcd_10103001',
+            name: 'Software as a service (SaaS) - business use',
+            description: 'Hosted software accessed online, sold to businesses for business use.',
+        },
+    ],
+});
+export const taxCodeRoutes = [
+    defineRoute({
+        operationId: 'listTaxCodes',
+        method: 'get',
+        path: '/v1/tax/codes',
+        tag: 'Tax',
+        summary: 'List tax codes',
+        description: 'Every product tax code Peable accepts: a complete list, `has_more` is `false`.',
+        auth: 'service',
+        scope: 'payments:read',
+        response: listOf(taxCodeSchema),
+        sdk: 'tax.listCodes',
+    }),
+];

package/dist/esm/resources/tax/complianceActions.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineObject } from '../../common/objects.js';
+import { listQuery } from '../../common/params.js';
+import { livemode, nullableString, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_ACTOR_TYPES } from '../../vocabulary/tax.js';
+import { taxFacts } from './shared.js';
+/** One recorded compliance change (`taxact_…`), written in the transaction of the change itself. */
+export const taxComplianceActionSchema = defineObject('tax.compliance_action', 'TaxComplianceAction', z
+    .object({
+    object: z.literal('tax.compliance_action'),
+    id: z.string().describe('`taxact_…`.'),
+    livemode,
+    action: z.string().describe('e.g. `business_profile.updated`, `review_item.resolved`.'),
+    actor: z.object({ type: z.enum(TAX_ACTOR_TYPES), id: nullableString }).strict(),
+    object_type: z.string(),
+    object_id: nullableString,
+    details: taxFacts.describe('Field names and statuses that changed — never the values of a document or a number.'),
+    created: unixSeconds,
+})
+    .strict(), {
+    examples: [
+        {
+            object: 'tax.compliance_action',
+            id: 'taxact_0193b8f2c1a87d3e9f4a',
+            livemode: false,
+            action: 'review_item.resolved',
+            actor: { type: 'user', id: 'user_42' },
+            object_type: 'tax.review_item',
+            object_id: 'taxrev_0193b8f2c1a87d3e9f4a',
+            details: { decision: 'will_register' },
+            created: 1793750400,
+        },
+    ],
+});
+export const listTaxComplianceActionsQuery = listQuery({});
+export const taxComplianceActionRoutes = [
+    defineRoute({
+        operationId: 'listTaxComplianceActions',
+        method: 'get',
+        path: '/v1/tax/compliance_actions',
+        tag: 'Tax compliance',
+        summary: 'List compliance actions',
+        description: 'The history of every compliance change, newest first.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: listTaxComplianceActionsQuery,
+        response: listOf(taxComplianceActionSchema),
+        sdk: 'tax.compliance.listActions',
+        expandable: 'tax.compliance_action',
+    }),
+];

package/dist/esm/resources/tax/deadlines.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { listOf } from '../../common/envelopes.js';
+import { defineComponent, defineObject } from '../../common/objects.js';
+import { nullableString, unixSeconds } from '../../common/primitives.js';
+import { defineRoute } from '../../route.js';
+import { TAX_DEADLINE_KINDS, TAX_DEADLINE_STATUSES } from '../../vocabulary/tax.js';
+import { taxRuleSourceSchema, taxState } from './shared.js';
+/**
+ * A due date the rule set can compute. `filing_status` is `not_tracked`:
+ * Peable files nothing, so it never claims a return was or was not filed.
+ */
+export const taxDeadlineSchema = defineObject('tax.deadline', 'TaxDeadline', z
+    .object({
+    object: z.literal('tax.deadline'),
+    kind: z.enum(TAX_DEADLINE_KINDS),
+    rule: z.string().describe('The rule that sets it.'),
+    country: nullableString,
+    state: taxState,
+    period_start: unixSeconds.nullable(),
+    period_end: unixSeconds.nullable(),
+    due: unixSeconds,
+    status: z.enum(TAX_DEADLINE_STATUSES),
+    filing_status: z.literal('not_tracked'),
+    description: z.string(),
+    source: taxRuleSourceSchema,
+})
+    .strict());
+/** Where a deadline exists but the rule set cannot compute it, and why. */
+export const taxDeadlineUnavailableSchema = defineComponent('TaxDeadlineUnavailable', z
+    .object({
+    rule: nullableString,
+    country: nullableString,
+    state: taxState,
+    reason: z.string(),
+})
+    .strict());
+/** A complete list (`has_more` is `false`), with what could not be computed beside it. */
+export const taxDeadlineListSchema = defineComponent('TaxDeadlineList', listOf(taxDeadlineSchema).extend({
+    unavailable: z
+        .array(taxDeadlineUnavailableSchema)
+        .describe('Where a deadline exists but the rule set cannot compute it, and why.'),
+}));
+export const taxDeadlineRoutes = [
+    defineRoute({
+        operationId: 'listTaxDeadlines',
+        method: 'get',
+        path: '/v1/tax/deadlines',
+        tag: 'Tax compliance',
+        summary: 'List tax deadlines',
+        description: 'Due dates the rule set computes from declared registrations and the latest assessment, soonest first.',
+        auth: 'service',
+        scope: 'payments:read',
+        response: taxDeadlineListSchema,
+        sdk: 'tax.compliance.listDeadlines',
+    }),
+];