@gpt-platform/client 0.10.5 → 0.11.0

package/dist/namespaces/compliance.d.ts

@@ -0,0 +1,2310 @@
+import type { AuditLog, AuditChainEntry, BreachIncident, BreachNotification, ConsentRecord, DataProtectionImpactAssessment, LegalDocument, LegalAcceptance, ProcessingActivity, RetentionPolicy, DataSubjectRequest, ScanResult, RiskAssessment, DataTransferRecord, CdeScopeReport, AccessLog, DisclosureLog, AmendmentRequest, ComplianceDocumentTemplate, BusinessAssociateAgreement, PolicyReviewSchedule, ComplianceRequirement, ComplianceRequirementCompletion, ComplianceOfficerDesignation, EphiAsset, EphiDataFlow, BreachNotificationArtifact } from "../_internal/types.gen";
+/** Attributes accepted when creating a breach incident. */
+export type CreateBreachIncidentAttributes = {
+    description: string;
+    severity?: string;
+    affected_record_count?: number;
+    data_categories?: string[];
+    discovered_at?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a consent record. */
+export type CreateConsentRecordAttributes = {
+    user_id: string;
+    consent_type: string;
+    document_version?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a DPIA. */
+export type CreateImpactAssessmentAttributes = {
+    title: string;
+    description?: string;
+    risk_level?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a DPIA (PATCH semantics). */
+export type UpdateImpactAssessmentAttributes = {
+    mitigating_measures?: string;
+    status?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a processing activity. */
+export type CreateProcessingActivityAttributes = {
+    name: string;
+    purpose?: string;
+    legal_basis?: string;
+    data_categories?: string[];
+    retention_period?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a retention policy. */
+export type CreateRetentionPolicyAttributes = {
+    name: string;
+    resource_type: string;
+    retention_days: number;
+    action_on_expiry?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a retention policy (PATCH semantics). */
+export type UpdateRetentionPolicyAttributes = {
+    retention_days?: number;
+    action_on_expiry?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a data subject request. */
+export type CreateDataSubjectRequestAttributes = {
+    request_type: string;
+    subject_email: string;
+    notes?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when creating a legal document. */
+export type CreateLegalDocumentAttributes = {
+    doc_type: string;
+    title: string;
+    content: string;
+    version?: string;
+    locale?: string;
+    [key: string]: unknown;
+};
+/** Attributes accepted when updating a legal document (PATCH semantics). */
+export type UpdateLegalDocumentAttributes = {
+    title?: string;
+    content?: string;
+    version?: string;
+    locale?: string;
+    [key: string]: unknown;
+};
+/** Compliance posture snapshot for a workspace. */
+export interface CompliancePosture {
+    workspace_id: string;
+    open_breaches: number;
+    total_breaches: number;
+    breach_breakdown: Record<string, number>;
+    overdue_dsrs: number;
+    pending_dsrs: number;
+    total_dsrs: number;
+    risk_assessments_by_level: Record<string, number>;
+    expiring_risk_assessments: number;
+    active_retention_policies: number;
+    total_retention_policies: number;
+    pii_scans_last_30d: number;
+    pii_scan_breakdown: Record<string, number>;
+    workspace_consents: number;
+    total_consent_subjects: number;
+    frameworks: ComplianceFrameworkReadiness[];
+}
+/** Regulatory framework readiness summary. */
+export interface ComplianceFrameworkReadiness {
+    framework: string;
+    requirements_met: number;
+    total_requirements: number;
+    coverage_percentage: number;
+    gaps: string[];
+}
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * Compliance namespace for HIPAA/GDPR audit logs, breach incidents,
+ * consent records, Data Protection Impact Assessments (DPIAs), processing
+ * activities, retention policies, data subject requests, legal documents,
+ * and PII scan results.
+ *
+ * Access via `client.compliance`.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // Record user consent
+ * const record = await client.compliance.consentRecords.create({
+ *   user_id: 'user_abc123',
+ *   consent_type: 'marketing_emails',
+ *   document_version: '2025-01',
+ * });
+ * ```
+ */
+export declare function createComplianceNamespace(rb: RequestBuilder): {
+    /**
+     * Audit Logs — immutable, append-only event trail.
+     *
+     * Every significant action on platform resources is recorded as an
+     * `AuditLog` entry. Entries are immutable — they cannot be modified
+     * or deleted via the API. Use `auditChain` for tamper-evident
+     * cryptographic verification of the log sequence.
+     */
+    auditLogs: {
+        /**
+         * List audit log entries with optional pagination.
+         *
+         * Returns one page of immutable audit log entries ordered by time
+         * (most recent first). Entries include actor identity, resource type,
+         * action performed, and timestamp.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `AuditLog` entries.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const logs = await client.compliance.auditLogs.list({ page: 1, pageSize: 50 });
+         * logs.forEach(l => console.log(l.attributes?.action, l.attributes?.actor_id));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<AuditLog[]>;
+    };
+    /**
+     * Audit Chain Entries — tamper-evident cryptographic audit chain.
+     *
+     * Each `AuditChainEntry` contains a hash of the previous entry, forming
+     * a linked chain. Verifying the chain integrity proves that no audit log
+     * entries have been inserted, deleted, or modified after the fact.
+     * Use for regulatory compliance evidence and forensic investigations.
+     */
+    auditChain: {
+        /**
+         * List audit chain entries with optional pagination.
+         *
+         * Returns chain entries in order. Each entry includes its own hash
+         * and the hash of the previous entry, enabling sequential verification.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `AuditChainEntry` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const chain = await client.compliance.auditChain.list({ pageSize: 100 });
+         * // Verify chain integrity by checking prev_hash matches prior entry hash
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<AuditChainEntry[]>;
+        /**
+         * Retrieve a single audit chain entry by its ID.
+         *
+         * Use to inspect a specific link in the chain, e.g., when verifying
+         * the hash of a particular audit log entry.
+         *
+         * @param id - The UUID of the audit chain entry.
+         * @param options - Optional request options.
+         * @returns The matching `AuditChainEntry` with hash values.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const entry = await client.compliance.auditChain.get('ace_abc123');
+         * console.log(entry.attributes?.hash, entry.attributes?.prev_hash);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<AuditChainEntry>;
+    };
+    /**
+     * Breach Incidents — data breach tracking and status management.
+     *
+     * GDPR Article 33 requires notification of data breaches to supervisory
+     * authorities within 72 hours of discovery. Use `create` to open an
+     * incident immediately upon discovery, then `updateStatus` to track
+     * the investigation and notification lifecycle.
+     */
+    breachIncidents: {
+        /**
+         * List breach incidents with optional pagination.
+         *
+         * Returns all breach incidents accessible to the current actor,
+         * ordered by `reported_at` descending (most recent first).
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BreachIncident` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const incidents = await client.compliance.breachIncidents.list();
+         * incidents.forEach(i => console.log(i.attributes?.status, i.attributes?.reported_at));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BreachIncident[]>;
+        /**
+         * Retrieve a single breach incident by its ID.
+         *
+         * @param id - The UUID of the breach incident.
+         * @param options - Optional request options.
+         * @returns The matching `BreachIncident` record.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const incident = await client.compliance.breachIncidents.get('bi_abc123');
+         * console.log(incident.attributes?.description, incident.attributes?.severity);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<BreachIncident>;
+        /**
+         * Report a new data breach incident.
+         *
+         * Creates a breach incident record. Under GDPR Article 33, breaches
+         * must be reported to the supervisory authority within 72 hours of
+         * discovery — call this immediately upon detection. Typical attributes:
+         * `description`, `severity` (`"low"` | `"medium"` | `"high"` | `"critical"`),
+         * `affected_record_count`, `data_categories`, and `discovered_at`.
+         *
+         * @param attributes - Incident details. `description` and `discovered_at`
+         *   are required by most regulatory frameworks.
+         * @param options - Optional request options.
+         * @returns The newly created `BreachIncident` with `status: "open"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const incident = await client.compliance.breachIncidents.create({
+         *   description: 'Unauthorized access to patient records via misconfigured API endpoint.',
+         *   severity: 'high',
+         *   affected_record_count: 342,
+         *   data_categories: ['health_data', 'contact_info'],
+         *   discovered_at: new Date().toISOString(),
+         * });
+         * console.log('Incident opened:', incident.id);
+         * ```
+         */
+        create: (attributes: CreateBreachIncidentAttributes, options?: RequestOptions) => Promise<BreachIncident>;
+        /**
+         * Update the status of a breach incident.
+         *
+         * Advances the incident through its lifecycle. Common status values:
+         * `"under_investigation"`, `"contained"`, `"notified"`, `"resolved"`,
+         * `"closed"`. Status transitions are logged for regulatory evidence.
+         *
+         * @param id - The UUID of the breach incident to update.
+         * @param status - The new status string.
+         * @param options - Optional request options.
+         * @returns The updated `BreachIncident` with the new status.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const incident = await client.compliance.breachIncidents.updateStatus(
+         *   'bi_abc123',
+         *   'contained',
+         * );
+         * console.log(incident.attributes?.status); // "contained"
+         * ```
+         */
+        updateStatus: (id: string, status: string, options?: RequestOptions) => Promise<BreachIncident>;
+    };
+    /**
+     * Breach Notifications — regulatory notification records for breach incidents.
+     *
+     * When a breach incident requires notifying a supervisory authority or
+     * affected data subjects, `BreachNotification` records track what was sent,
+     * to whom, and when. These are read-only via the client SDK — notifications
+     * are generated by the platform when `breachIncidents.updateStatus` transitions
+     * an incident to a notifiable state.
+     */
+    breachNotifications: {
+        /**
+         * List breach notifications with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BreachNotification` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const notifications = await client.compliance.breachNotifications.list();
+         * notifications.forEach(n => console.log(n.attributes?.recipient, n.attributes?.sent_at));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BreachNotification[]>;
+        /**
+         * Retrieve a single breach notification by its ID.
+         *
+         * @param id - The UUID of the breach notification.
+         * @param options - Optional request options.
+         * @returns The matching `BreachNotification` record.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const notification = await client.compliance.breachNotifications.get('bn_abc123');
+         * console.log(notification.attributes?.recipient_type, notification.attributes?.sent_at);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<BreachNotification>;
+    };
+    /**
+     * Consent Records — user consent tracking per GDPR Article 7.
+     *
+     * Every instance of user consent (e.g., accepting a privacy policy,
+     * opting in to marketing) should be recorded here. Records are immutable
+     * once created. Withdrawal creates a new record with `withdrawn: true`
+     * rather than modifying the original.
+     */
+    consentRecords: {
+        /**
+         * List consent records with optional pagination.
+         *
+         * Returns all consent records accessible to the current actor.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ConsentRecord` entries.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const records = await client.compliance.consentRecords.list({ pageSize: 100 });
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ConsentRecord[]>;
+        /**
+         * Retrieve a single consent record by its ID.
+         *
+         * @param id - The UUID of the consent record.
+         * @param options - Optional request options.
+         * @returns The matching `ConsentRecord`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const record = await client.compliance.consentRecords.get('cr_abc123');
+         * console.log(record.attributes?.consent_type, record.attributes?.withdrawn);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ConsentRecord>;
+        /**
+         * List currently active (non-withdrawn) consent records.
+         *
+         * Returns only records where `withdrawn` is `false` or `null`.
+         * Useful for determining which consents are currently in effect for
+         * a user before sending communications or processing their data.
+         *
+         * @param options - Optional request options.
+         * @returns All active `ConsentRecord` entries.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const active = await client.compliance.consentRecords.listActive();
+         * const hasMarketingConsent = active.some(
+         *   r => r.attributes?.consent_type === 'marketing_emails',
+         * );
+         * ```
+         */
+        listActive: (options?: RequestOptions) => Promise<ConsentRecord[]>;
+        /**
+         * Record a new instance of user consent.
+         *
+         * Creates an immutable consent record. Typical attributes:
+         * `user_id`, `consent_type` (e.g., `"marketing_emails"`, `"terms_of_service"`),
+         * `document_version` (the legal document version accepted), and
+         * `ip_address` / `user_agent` for evidentiary purposes.
+         *
+         * @param attributes - Consent attributes. `user_id` and `consent_type` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `ConsentRecord`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const record = await client.compliance.consentRecords.create({
+         *   user_id: 'user_abc123',
+         *   consent_type: 'marketing_emails',
+         *   document_version: '2025-01',
+         * });
+         * console.log('Consent recorded:', record.id);
+         * ```
+         */
+        create: (attributes: CreateConsentRecordAttributes, options?: RequestOptions) => Promise<ConsentRecord>;
+        /**
+         * Withdraw a previously given consent.
+         *
+         * Marks the consent record as withdrawn. Under GDPR, users have the right
+         * to withdraw consent at any time. Withdrawal creates an audit trail and
+         * the record is preserved for regulatory evidence. The original record
+         * remains accessible but is marked `withdrawn: true` with a `withdrawn_at`
+         * timestamp.
+         *
+         * @param id - The UUID of the consent record to withdraw.
+         * @param options - Optional request options.
+         * @returns The updated `ConsentRecord` with `withdrawn: true`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const record = await client.compliance.consentRecords.withdraw('cr_abc123');
+         * console.log(record.attributes?.withdrawn); // true
+         * console.log(record.attributes?.withdrawn_at);
+         * ```
+         */
+        withdraw: (id: string, options?: RequestOptions) => Promise<ConsentRecord>;
+    };
+    /**
+     * Impact Assessments — Data Protection Impact Assessments (DPIA).
+     *
+     * GDPR Article 35 requires a DPIA before processing activities that are
+     * likely to result in high risks to individuals. DPIAs document the nature
+     * of processing, its necessity, risk assessment, and mitigating measures.
+     * An assessment moves through `draft` → `review` → `approved` states.
+     */
+    impactAssessments: {
+        /**
+         * List Data Protection Impact Assessments with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `DataProtectionImpactAssessment` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const dpias = await client.compliance.impactAssessments.list();
+         * dpias.forEach(d => console.log(d.attributes?.title, d.attributes?.status));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<DataProtectionImpactAssessment[]>;
+        /**
+         * Retrieve a single DPIA by its ID.
+         *
+         * @param id - The UUID of the DPIA.
+         * @param options - Optional request options.
+         * @returns The matching `DataProtectionImpactAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const dpia = await client.compliance.impactAssessments.get('dpia_abc123');
+         * console.log(dpia.attributes?.risk_level, dpia.attributes?.status);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<DataProtectionImpactAssessment>;
+        /**
+         * Create a new Data Protection Impact Assessment.
+         *
+         * Opens a DPIA in `draft` status. Typical attributes: `title`,
+         * `description`, `processing_activity_id` (link to the relevant
+         * processing activity), `risk_level`, and `mitigating_measures`.
+         *
+         * @param attributes - DPIA attributes. `title` is required.
+         * @param options - Optional request options.
+         * @returns The newly created `DataProtectionImpactAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const dpia = await client.compliance.impactAssessments.create({
+         *   title: 'AI-Assisted Clinical Note Processing DPIA',
+         *   description: 'Assessment of risk for processing PHI through LLM pipeline.',
+         *   risk_level: 'high',
+         * });
+         * console.log('DPIA created:', dpia.id);
+         * ```
+         */
+        create: (attributes: CreateImpactAssessmentAttributes, options?: RequestOptions) => Promise<DataProtectionImpactAssessment>;
+        /**
+         * Update an existing Data Protection Impact Assessment.
+         *
+         * Used to add or revise sections of a DPIA while it is in `draft` or
+         * `review` status. Approved assessments may be locked against edits
+         * depending on server policy.
+         *
+         * @param id - The UUID of the DPIA to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `DataProtectionImpactAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const dpia = await client.compliance.impactAssessments.update('dpia_abc123', {
+         *   mitigating_measures: 'Data minimized. Encryption at rest and in transit.',
+         *   status: 'review',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateImpactAssessmentAttributes, options?: RequestOptions) => Promise<DataProtectionImpactAssessment>;
+        /**
+         * Approve a Data Protection Impact Assessment.
+         *
+         * Transitions the DPIA from `review` to `approved` status. Records the
+         * approver's identity (from the current actor) and approval timestamp.
+         * Approved DPIAs are locked against further edits.
+         *
+         * @param id - The UUID of the DPIA to approve.
+         * @param options - Optional request options.
+         * @returns The updated `DataProtectionImpactAssessment` with `status: "approved"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const dpia = await client.compliance.impactAssessments.approve('dpia_abc123');
+         * console.log(dpia.attributes?.status); // "approved"
+         * console.log(dpia.attributes?.approved_at);
+         * ```
+         */
+        approve: (id: string, options?: RequestOptions) => Promise<DataProtectionImpactAssessment>;
+    };
+    /**
+     * Processing Activities — GDPR Article 30 records of processing.
+     *
+     * Article 30 requires organizations to maintain records of all processing
+     * activities. Each record describes a processing activity: what data is
+     * processed, for what purpose, under what legal basis, and with which
+     * third-party processors.
+     */
+    processingActivities: {
+        /**
+         * List processing activity records with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ProcessingActivity` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const activities = await client.compliance.processingActivities.list();
+         * activities.forEach(a => console.log(a.attributes?.name, a.attributes?.legal_basis));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ProcessingActivity[]>;
+        /**
+         * Retrieve a single processing activity by its ID.
+         *
+         * @param id - The UUID of the processing activity.
+         * @param options - Optional request options.
+         * @returns The matching `ProcessingActivity`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const activity = await client.compliance.processingActivities.get('pa_abc123');
+         * console.log(activity.attributes?.data_categories);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ProcessingActivity>;
+        /**
+         * Create a new processing activity record.
+         *
+         * Typical attributes: `name`, `purpose`, `legal_basis`
+         * (e.g., `"legitimate_interest"`, `"consent"`, `"contract"`),
+         * `data_categories`, `data_subjects`, `recipients`, and `retention_period`.
+         *
+         * @param attributes - Processing activity attributes. `name` and `purpose`
+         *   are required by GDPR Article 30.
+         * @param options - Optional request options.
+         * @returns The newly created `ProcessingActivity`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const activity = await client.compliance.processingActivities.create({
+         *   name: 'Clinical Note AI Processing',
+         *   purpose: 'Generate structured clinical documentation from voice recordings.',
+         *   legal_basis: 'consent',
+         *   data_categories: ['health_data', 'biometric_data'],
+         *   retention_period: '7 years',
+         * });
+         * ```
+         */
+        create: (attributes: CreateProcessingActivityAttributes, options?: RequestOptions) => Promise<ProcessingActivity>;
+        /**
+         * Delete a processing activity record.
+         *
+         * Use with caution — regulatory requirements may mandate that Article 30
+         * records be retained for the life of the organization.
+         *
+         * @param id - The UUID of the processing activity to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.compliance.processingActivities.delete('pa_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Retention Policies — data lifecycle and automated deletion rules.
+     *
+     * Retention policies specify how long different categories of data should
+     * be kept and what happens when the retention period expires (deletion,
+     * anonymization, archival). Policies are evaluated by the platform's
+     * retention worker on a scheduled basis.
+     */
+    retentionPolicies: {
+        /**
+         * List retention policies with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `RetentionPolicy` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const policies = await client.compliance.retentionPolicies.list();
+         * policies.forEach(p => console.log(p.attributes?.name, p.attributes?.retention_days));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<RetentionPolicy[]>;
+        /**
+         * Retrieve a single retention policy by its ID.
+         *
+         * @param id - The UUID of the retention policy.
+         * @param options - Optional request options.
+         * @returns The matching `RetentionPolicy`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const policy = await client.compliance.retentionPolicies.get('rp_abc123');
+         * console.log(policy.attributes?.action_on_expiry);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<RetentionPolicy>;
+        /**
+         * Create a new retention policy.
+         *
+         * Typical attributes: `name`, `resource_type` (the type of data governed),
+         * `retention_days`, and `action_on_expiry`
+         * (`"delete"` | `"anonymize"` | `"archive"`).
+         *
+         * @param attributes - Retention policy attributes. `name`, `resource_type`,
+         *   and `retention_days` are required.
+         * @param options - Optional request options.
+         * @returns The newly created `RetentionPolicy`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const policy = await client.compliance.retentionPolicies.create({
+         *   name: 'Voice Session 7-Year Retention',
+         *   resource_type: 'voice_session',
+         *   retention_days: 2555, // ~7 years
+         *   action_on_expiry: 'delete',
+         * });
+         * ```
+         */
+        create: (attributes: CreateRetentionPolicyAttributes, options?: RequestOptions) => Promise<RetentionPolicy>;
+        /**
+         * Update an existing retention policy.
+         *
+         * Use to change retention duration, action on expiry, or applicability
+         * filters. Changes take effect on the next scheduler run.
+         *
+         * @param id - The UUID of the retention policy to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `RetentionPolicy`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const policy = await client.compliance.retentionPolicies.update('rp_abc123', {
+         *   retention_days: 3650, // Extend to 10 years
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateRetentionPolicyAttributes, options?: RequestOptions) => Promise<RetentionPolicy>;
+        /**
+         * Delete a retention policy.
+         *
+         * After deletion, data previously governed by this policy will no longer
+         * be subject to automated expiry actions. Existing data is not immediately
+         * affected.
+         *
+         * @param id - The UUID of the retention policy to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.compliance.retentionPolicies.delete('rp_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Data Subject Requests — GDPR rights of access, erasure, and portability.
+     *
+     * GDPR grants data subjects rights including: right of access (Article 15),
+     * right to erasure (Article 17), right to data portability (Article 20).
+     * Use `create` when a user submits such a request. Track progress and
+     * outcomes via `updateStatus`.
+     */
+    dataSubjectRequests: {
+        /**
+         * List data subject requests with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `DataSubjectRequest` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const requests = await client.compliance.dataSubjectRequests.list();
+         * requests.forEach(r => console.log(r.attributes?.request_type, r.attributes?.status));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<DataSubjectRequest[]>;
+        /**
+         * Retrieve a single data subject request by its ID.
+         *
+         * @param id - The UUID of the data subject request.
+         * @param options - Optional request options.
+         * @returns The matching `DataSubjectRequest`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const request = await client.compliance.dataSubjectRequests.get('dsr_abc123');
+         * console.log(request.attributes?.request_type, request.attributes?.due_by);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<DataSubjectRequest>;
+        /**
+         * Submit a new data subject request.
+         *
+         * Creates a request record for processing. Typical attributes:
+         * `request_type` (e.g., `"access"`, `"erasure"`, `"portability"`),
+         * `subject_email`, `subject_id`, and any supporting `notes`.
+         * The platform may automatically calculate a `due_by` date based on
+         * GDPR's 30-day response requirement.
+         *
+         * @param attributes - Request attributes. `request_type` and `subject_email`
+         *   are required.
+         * @param options - Optional request options.
+         * @returns The newly created `DataSubjectRequest` with `status: "pending"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const request = await client.compliance.dataSubjectRequests.create({
+         *   request_type: 'erasure',
+         *   subject_email: 'jane@example.com',
+         *   notes: 'User requested full account deletion via settings page.',
+         * });
+         * console.log('DSR created, due by:', request.attributes?.due_by);
+         * ```
+         */
+        create: (attributes: CreateDataSubjectRequestAttributes, options?: RequestOptions) => Promise<DataSubjectRequest>;
+        /**
+         * Update the status of a data subject request.
+         *
+         * Advances the request through its handling lifecycle. Common status values:
+         * `"in_progress"`, `"awaiting_verification"`, `"completed"`, `"rejected"`.
+         * Status changes are time-stamped and added to the audit trail.
+         *
+         * @param id - The UUID of the data subject request.
+         * @param status - The new status string.
+         * @param options - Optional request options.
+         * @returns The updated `DataSubjectRequest` with the new status.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const request = await client.compliance.dataSubjectRequests.updateStatus(
+         *   'dsr_abc123',
+         *   'completed',
+         * );
+         * console.log(request.attributes?.status); // "completed"
+         * ```
+         */
+        updateStatus: (id: string, status: string, options?: RequestOptions) => Promise<DataSubjectRequest>;
+    };
+    /**
+     * Legal Documents — Terms of Service, Privacy Policy, and other legal agreements.
+     *
+     * Legal documents are versioned and locale-aware. Draft documents can be
+     * edited freely; published documents are visible to end users and drive
+     * the consent flow. Use `publish` / `unpublish` to control visibility.
+     */
+    legalDocuments: {
+        /**
+         * List legal documents with optional pagination.
+         *
+         * Returns all legal documents (draft and published) accessible to the
+         * current actor.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `LegalDocument` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const docs = await client.compliance.legalDocuments.list();
+         * docs.forEach(d => console.log(d.attributes?.doc_type, d.attributes?.published));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<LegalDocument[]>;
+        /**
+         * Retrieve a single legal document by its ID.
+         *
+         * @param id - The UUID of the legal document.
+         * @param options - Optional request options.
+         * @returns The matching `LegalDocument`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const doc = await client.compliance.legalDocuments.get('ld_abc123');
+         * console.log(doc.attributes?.version, doc.attributes?.content);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<LegalDocument>;
+        /**
+         * Create a new legal document (initially in draft status).
+         *
+         * Typical attributes: `doc_type` (e.g., `"terms_of_service"`,
+         * `"privacy_policy"`), `title`, `content` (HTML or Markdown),
+         * `version`, and `locale` (BCP-47 language tag, e.g., `"en-US"`).
+         *
+         * @param attributes - Legal document attributes. `doc_type` and `title`
+         *   are required.
+         * @param options - Optional request options.
+         * @returns The newly created `LegalDocument` in draft status.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const doc = await client.compliance.legalDocuments.create({
+         *   doc_type: 'privacy_policy',
+         *   title: 'Privacy Policy v2.0',
+         *   content: '<h1>Privacy Policy</h1><p>...</p>',
+         *   version: '2025-03',
+         *   locale: 'en-US',
+         * });
+         * ```
+         */
+        create: (attributes: CreateLegalDocumentAttributes, options?: RequestOptions) => Promise<LegalDocument>;
+        /**
+         * Update a legal document.
+         *
+         * Edits are only permitted on draft documents. Published documents must
+         * be unpublished before they can be edited.
+         *
+         * @param id - The UUID of the legal document to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `LegalDocument`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const doc = await client.compliance.legalDocuments.update('ld_abc123', {
+         *   content: '<h1>Updated Privacy Policy</h1><p>...</p>',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: UpdateLegalDocumentAttributes, options?: RequestOptions) => Promise<LegalDocument>;
+        /**
+         * Delete a legal document.
+         *
+         * Only draft documents can be deleted. Published documents must be
+         * unpublished before deletion.
+         *
+         * @param id - The UUID of the legal document to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.compliance.legalDocuments.delete('ld_abc123');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+        /**
+         * Retrieve legal documents filtered by locale.
+         *
+         * Returns published legal documents for the specified BCP-47 locale
+         * (e.g., `"en-US"`, `"fr-FR"`). Used to display the correct language
+         * version of legal documents to end users.
+         *
+         * @param locale - A BCP-47 locale string (e.g., `"en-US"`).
+         * @param options - Optional request options.
+         * @returns An array of published `LegalDocument` records for that locale.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const docs = await client.compliance.legalDocuments.byLocale('fr-FR');
+         * docs.forEach(d => console.log(d.attributes?.title));
+         * ```
+         */
+        byLocale: (locale: string, options?: RequestOptions) => Promise<LegalDocument[]>;
+        /**
+         * Retrieve published legal documents for the current application.
+         *
+         * Returns documents scoped to the application identified by the
+         * `x-application-key` request header. Used to load the correct
+         * legal documents for white-labeled or multi-tenant applications.
+         *
+         * @param options - Optional request options.
+         * @returns An array of published `LegalDocument` records for the current application.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const docs = await client.compliance.legalDocuments.forApplication();
+         * const tos = docs.find(d => d.attributes?.doc_type === 'terms_of_service');
+         * ```
+         */
+        forApplication: (options?: RequestOptions) => Promise<LegalDocument[]>;
+        /**
+         * Publish a legal document, making it visible to end users.
+         *
+         * Transitions the document from `draft` to `published` status. Once
+         * published, the document appears in the consent flow and can be
+         * accepted by users. Publishing is recorded with a `published_at`
+         * timestamp for auditability.
+         *
+         * @param id - The UUID of the legal document to publish.
+         * @param options - Optional request options.
+         * @returns The updated `LegalDocument` with `published: true`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const doc = await client.compliance.legalDocuments.publish('ld_abc123');
+         * console.log(doc.attributes?.published_at);
+         * ```
+         */
+        publish: (id: string, options?: RequestOptions) => Promise<LegalDocument>;
+        /**
+         * Unpublish a legal document, removing it from end-user visibility.
+         *
+         * Transitions the document from `published` back to `draft` status.
+         * Useful when a document needs to be revised. Previously accepted
+         * consent records are not affected by unpublishing.
+         *
+         * @param id - The UUID of the legal document to unpublish.
+         * @param options - Optional request options.
+         * @returns The updated `LegalDocument` with `published: false`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const doc = await client.compliance.legalDocuments.unpublish('ld_abc123');
+         * console.log(doc.attributes?.published); // false
+         * ```
+         */
+        unpublish: (id: string, options?: RequestOptions) => Promise<LegalDocument>;
+    };
+    /**
+     * Legal Acceptances — records of user acceptance of legal documents.
+     *
+     * When a user accepts a legal document (e.g., clicks "I agree" on Terms of
+     * Service), a `LegalAcceptance` record is created. These records are
+     * immutable and serve as evidentiary proof of agreement. Use `latest` to
+     * check whether the current user has accepted the most recent version of
+     * all required documents.
+     */
+    legalAcceptances: {
+        /**
+         * List legal acceptance records with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `LegalAcceptance` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const acceptances = await client.compliance.legalAcceptances.list();
+         * acceptances.forEach(a => console.log(a.attributes?.accepted_at));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<LegalAcceptance[]>;
+        /**
+         * Retrieve a single legal acceptance record by its ID.
+         *
+         * @param id - The UUID of the legal acceptance record.
+         * @param options - Optional request options.
+         * @returns The matching `LegalAcceptance`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const acceptance = await client.compliance.legalAcceptances.get('la_abc123');
+         * console.log(acceptance.attributes?.document_version);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<LegalAcceptance>;
+        /**
+         * Get the latest legal acceptance record for the currently authenticated user.
+         *
+         * Returns the most recent acceptance record, useful for gating access
+         * behind an "accept updated terms" prompt when a new document version
+         * has been published since the user last accepted.
+         *
+         * @param options - Optional request options.
+         * @returns The latest `LegalAcceptance` for the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const latest = await client.compliance.legalAcceptances.latest();
+         * if (latest.attributes?.document_version !== currentDocVersion) {
+         *   // Prompt user to accept updated terms
+         * }
+         * ```
+         */
+        latest: (options?: RequestOptions) => Promise<LegalAcceptance>;
+    };
+    /**
+     * Scan Results — PII detection and security scan findings.
+     *
+     * The platform runs automated PII and security scans on documents,
+     * messages, and storage objects. `ScanResult` records capture what was
+     * found: entity types, locations within the content, confidence scores,
+     * and remediation status. These are generated by the platform and are
+     * read-only via the client SDK.
+     */
+    scanResults: {
+        /**
+         * List PII/security scan results with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ScanResult` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const results = await client.compliance.scanResults.list({ pageSize: 50 });
+         * results.forEach(r => console.log(r.attributes?.entity_type, r.attributes?.risk_level));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ScanResult[]>;
+        /**
+         * Retrieve a single scan result by its ID.
+         *
+         * @param id - The UUID of the scan result.
+         * @param options - Optional request options.
+         * @returns The matching `ScanResult` with entity details and location info.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.compliance.scanResults.get('sr_abc123');
+         * console.log(result.attributes?.entity_type, result.attributes?.confidence);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ScanResult>;
+    };
+    /**
+     * Get aggregated compliance posture for a workspace.
+     *
+     * Returns breach stats, DSR metrics, risk assessments, retention policies,
+     * PII scan coverage, consent tracking, and regulatory framework readiness
+     * in a single call.
+     *
+     * @param params - Must include `workspace_id`
+     * @param options - Request options
+     * @returns {@link CompliancePosture} snapshot
+     *
+     * @example
+     * ```typescript
+     * const posture = await client.compliance.getPosture({ workspace_id: "..." });
+     * console.log(posture.open_breaches, posture.frameworks);
+     * ```
+     */
+    getPosture: (params: {
+        workspace_id: string;
+    }, options?: RequestOptions) => Promise<CompliancePosture>;
+    /**
+     * Risk Assessments — formal risk evaluation records.
+     *
+     * Track risk assessments for data processing activities, infrastructure,
+     * and third-party integrations. Assessments can be created, reviewed via
+     * status updates, and deleted when superseded.
+     */
+    riskAssessments: {
+        /**
+         * List risk assessments with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `RiskAssessment` records.
+         *
+         * @example
+         * ```typescript
+         * const assessments = await client.compliance.riskAssessments.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<RiskAssessment[]>;
+        /**
+         * Retrieve a single risk assessment by ID.
+         *
+         * @param id - The UUID of the risk assessment.
+         * @param options - Optional request options.
+         * @returns The matching `RiskAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const assessment = await client.compliance.riskAssessments.get('ra-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<RiskAssessment>;
+        /**
+         * Create a new risk assessment.
+         *
+         * @param attributes - Risk assessment attributes.
+         * @param options - Optional request options.
+         * @returns The newly created `RiskAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const assessment = await client.compliance.riskAssessments.create({
+         *   title: 'LLM Pipeline Risk Assessment',
+         *   risk_level: 'high',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<RiskAssessment>;
+        /**
+         * Update the status of a risk assessment.
+         *
+         * @param id - The UUID of the risk assessment.
+         * @param attributes - Attributes to update (e.g., `{ status: "mitigated" }`).
+         * @param options - Optional request options.
+         * @returns The updated `RiskAssessment`.
+         *
+         * @example
+         * ```typescript
+         * const assessment = await client.compliance.riskAssessments.updateStatus(
+         *   'ra-uuid', { status: 'mitigated' },
+         * );
+         * ```
+         */
+        updateStatus: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<RiskAssessment>;
+        /**
+         * Delete a risk assessment.
+         *
+         * @param id - The UUID of the risk assessment to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * await client.compliance.riskAssessments.delete('ra-uuid');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Data Transfer Records — cross-border and third-party data transfer tracking.
+     *
+     * GDPR Chapter V requires documentation of international data transfers.
+     * Each record captures the transfer mechanism, recipient country, and
+     * safeguards in place.
+     */
+    dataTransferRecords: {
+        /**
+         * List data transfer records with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `DataTransferRecord` records.
+         *
+         * @example
+         * ```typescript
+         * const transfers = await client.compliance.dataTransferRecords.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<DataTransferRecord[]>;
+        /**
+         * Retrieve a single data transfer record by ID.
+         *
+         * @param id - The UUID of the data transfer record.
+         * @param options - Optional request options.
+         * @returns The matching `DataTransferRecord`.
+         *
+         * @example
+         * ```typescript
+         * const transfer = await client.compliance.dataTransferRecords.get('dtr-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<DataTransferRecord>;
+        /**
+         * Create a new data transfer record.
+         *
+         * @param attributes - Data transfer attributes (recipient, country, mechanism, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `DataTransferRecord`.
+         *
+         * @example
+         * ```typescript
+         * const transfer = await client.compliance.dataTransferRecords.create({
+         *   recipient: 'Cloud Provider EU',
+         *   destination_country: 'DE',
+         *   transfer_mechanism: 'standard_contractual_clauses',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<DataTransferRecord>;
+        /**
+         * Delete a data transfer record.
+         *
+         * @param id - The UUID of the data transfer record to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * await client.compliance.dataTransferRecords.delete('dtr-uuid');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * CDE Scope Reports — Cardholder Data Environment scope documentation.
+     *
+     * PCI DSS requires documenting the scope of systems that store, process,
+     * or transmit cardholder data. Each report captures the CDE boundary
+     * and connected systems.
+     */
+    cdeScopeReports: {
+        /**
+         * List CDE scope reports with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `CdeScopeReport` records.
+         *
+         * @example
+         * ```typescript
+         * const reports = await client.compliance.cdeScopeReports.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<CdeScopeReport[]>;
+        /**
+         * Retrieve a single CDE scope report by ID.
+         *
+         * @param id - The UUID of the CDE scope report.
+         * @param options - Optional request options.
+         * @returns The matching `CdeScopeReport`.
+         *
+         * @example
+         * ```typescript
+         * const report = await client.compliance.cdeScopeReports.get('csr-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<CdeScopeReport>;
+        /**
+         * Create a new CDE scope report.
+         *
+         * @param attributes - CDE scope report attributes.
+         * @param options - Optional request options.
+         * @returns The newly created `CdeScopeReport`.
+         *
+         * @example
+         * ```typescript
+         * const report = await client.compliance.cdeScopeReports.create({
+         *   title: 'Q1 2026 CDE Scope',
+         *   systems_in_scope: ['payment-gateway', 'billing-db'],
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<CdeScopeReport>;
+        /**
+         * Delete a CDE scope report.
+         *
+         * @param id - The UUID of the CDE scope report to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * await client.compliance.cdeScopeReports.delete('csr-uuid');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Access Logs — read-only access audit trail.
+     *
+     * Records of who accessed what data and when. Generated automatically
+     * by the platform. Access logs are immutable and cannot be created,
+     * modified, or deleted via the API.
+     */
+    accessLogs: {
+        /**
+         * List access logs with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `AccessLog` records.
+         *
+         * @example
+         * ```typescript
+         * const logs = await client.compliance.accessLogs.list({ pageSize: 100 });
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<AccessLog[]>;
+        /**
+         * Retrieve a single access log entry by ID.
+         *
+         * @param id - The UUID of the access log entry.
+         * @param options - Optional request options.
+         * @returns The matching `AccessLog`.
+         *
+         * @example
+         * ```typescript
+         * const log = await client.compliance.accessLogs.get('al-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<AccessLog>;
+    };
+    /**
+     * Disclosure Logs — records of data disclosures to third parties.
+     *
+     * HIPAA and state privacy laws require tracking disclosures of protected
+     * information. Each log entry records what was disclosed, to whom, and
+     * the legal basis for the disclosure.
+     */
+    disclosureLogs: {
+        /**
+         * List disclosure logs with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `DisclosureLog` records.
+         *
+         * @example
+         * ```typescript
+         * const logs = await client.compliance.disclosureLogs.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<DisclosureLog[]>;
+        /**
+         * Retrieve a single disclosure log by ID.
+         *
+         * @param id - The UUID of the disclosure log.
+         * @param options - Optional request options.
+         * @returns The matching `DisclosureLog`.
+         *
+         * @example
+         * ```typescript
+         * const log = await client.compliance.disclosureLogs.get('dl-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<DisclosureLog>;
+        /**
+         * Create a new disclosure log entry.
+         *
+         * @param attributes - Disclosure details (recipient, purpose, data categories, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `DisclosureLog`.
+         *
+         * @example
+         * ```typescript
+         * const log = await client.compliance.disclosureLogs.create({
+         *   recipient: 'Insurance Provider',
+         *   purpose: 'claims_processing',
+         *   data_categories: ['health_data'],
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<DisclosureLog>;
+        /**
+         * List disclosure logs filtered by data subject.
+         *
+         * Returns all disclosures related to a specific data subject,
+         * useful for fulfilling HIPAA accounting-of-disclosures requests.
+         *
+         * @param options - Filter by subject type/ID, plus optional pagination and request options.
+         * @returns An array of `DisclosureLog` records for the subject.
+         *
+         * @example
+         * ```typescript
+         * const logs = await client.compliance.disclosureLogs.listBySubject({
+         *   filter: { subject_type: { eq: 'patient' }, subject_id: { eq: 'subj-123' } },
+         * });
+         * ```
+         */
+        listBySubject: (options?: {
+            filter?: Record<string, unknown>;
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<DisclosureLog[]>;
+    };
+    /**
+     * Amendment Requests — requests to correct or amend records.
+     *
+     * HIPAA gives patients the right to request amendments to their health
+     * records. Each request goes through a review workflow: create, review,
+     * approve/deny, and apply.
+     */
+    amendmentRequests: {
+        /**
+         * List amendment requests with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `AmendmentRequest` records.
+         *
+         * @example
+         * ```typescript
+         * const requests = await client.compliance.amendmentRequests.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<AmendmentRequest[]>;
+        /**
+         * Retrieve a single amendment request by ID.
+         *
+         * @param id - The UUID of the amendment request.
+         * @param options - Optional request options.
+         * @returns The matching `AmendmentRequest`.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.get('ar-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<AmendmentRequest>;
+        /**
+         * Create a new amendment request.
+         *
+         * @param attributes - Amendment request details (record reference, requested changes, reason).
+         * @param options - Optional request options.
+         * @returns The newly created `AmendmentRequest`.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.create({
+         *   record_id: 'patient-record-uuid',
+         *   requested_change: 'Correct diagnosis code from E11.9 to E10.9',
+         *   reason: 'Misclassification during initial intake.',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<AmendmentRequest>;
+        /**
+         * Mark an amendment request as under review.
+         *
+         * @param id - The UUID of the amendment request.
+         * @param attributes - Optional review attributes.
+         * @param options - Optional request options.
+         * @returns The updated `AmendmentRequest`.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.review('ar-uuid');
+         * ```
+         */
+        review: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<AmendmentRequest>;
+        /**
+         * Approve an amendment request.
+         *
+         * @param id - The UUID of the amendment request.
+         * @param attributes - Optional approval attributes.
+         * @param options - Optional request options.
+         * @returns The updated `AmendmentRequest` with approved status.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.approve('ar-uuid');
+         * ```
+         */
+        approve: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<AmendmentRequest>;
+        /**
+         * Deny an amendment request.
+         *
+         * @param id - The UUID of the amendment request.
+         * @param attributes - Optional denial reason attributes.
+         * @param options - Optional request options.
+         * @returns The updated `AmendmentRequest` with denied status.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.deny('ar-uuid', {
+         *   denial_reason: 'Record is accurate as documented.',
+         * });
+         * ```
+         */
+        deny: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<AmendmentRequest>;
+        /**
+         * Apply an approved amendment to the target record.
+         *
+         * @param id - The UUID of the amendment request.
+         * @param attributes - Optional application attributes.
+         * @param options - Optional request options.
+         * @returns The updated `AmendmentRequest` with applied status.
+         *
+         * @example
+         * ```typescript
+         * const request = await client.compliance.amendmentRequests.apply('ar-uuid');
+         * ```
+         */
+        apply: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<AmendmentRequest>;
+    };
+    /**
+     * Compliance Document Templates — reusable templates for compliance documentation.
+     *
+     * Templates provide standardized starting points for policies, procedures,
+     * and forms required by regulatory frameworks. Templates can be cloned
+     * to create workspace-specific documents.
+     */
+    complianceDocumentTemplates: {
+        /**
+         * List compliance document templates with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ComplianceDocumentTemplate` records.
+         *
+         * @example
+         * ```typescript
+         * const templates = await client.compliance.complianceDocumentTemplates.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ComplianceDocumentTemplate[]>;
+        /**
+         * Retrieve a single compliance document template by ID.
+         *
+         * @param id - The UUID of the template.
+         * @param options - Optional request options.
+         * @returns The matching `ComplianceDocumentTemplate`.
+         *
+         * @example
+         * ```typescript
+         * const template = await client.compliance.complianceDocumentTemplates.get('tpl-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ComplianceDocumentTemplate>;
+        /**
+         * Create a new compliance document template.
+         *
+         * @param attributes - Template attributes (title, content, framework, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `ComplianceDocumentTemplate`.
+         *
+         * @example
+         * ```typescript
+         * const template = await client.compliance.complianceDocumentTemplates.create({
+         *   title: 'HIPAA Privacy Policy Template',
+         *   framework: 'hipaa',
+         *   content: '# Privacy Policy\n...',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceDocumentTemplate>;
+        /**
+         * Update a compliance document template.
+         *
+         * @param id - The UUID of the template to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `ComplianceDocumentTemplate`.
+         *
+         * @example
+         * ```typescript
+         * const template = await client.compliance.complianceDocumentTemplates.update(
+         *   'tpl-uuid', { content: '# Updated Policy\n...' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceDocumentTemplate>;
+        /**
+         * Clone a compliance document template into a new document.
+         *
+         * Creates a copy of the template that can be customized independently.
+         *
+         * @param attributes - Clone attributes (e.g., target workspace or overrides).
+         * @param options - Optional request options.
+         * @returns The cloned `ComplianceDocumentTemplate`.
+         *
+         * @example
+         * ```typescript
+         * const cloned = await client.compliance.complianceDocumentTemplates.clone({
+         *   source_template_id: 'tpl-uuid',
+         *   title: 'Our HIPAA Privacy Policy',
+         * });
+         * ```
+         */
+        clone: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceDocumentTemplate>;
+    };
+    /**
+     * Business Associate Agreements — HIPAA BAA lifecycle management.
+     *
+     * HIPAA requires covered entities to execute BAAs with business associates
+     * who handle PHI. Track agreements through creation, signing, and
+     * termination.
+     */
+    businessAssociateAgreements: {
+        /**
+         * List business associate agreements with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BusinessAssociateAgreement` records.
+         *
+         * @example
+         * ```typescript
+         * const baas = await client.compliance.businessAssociateAgreements.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BusinessAssociateAgreement[]>;
+        /**
+         * Retrieve a single BAA by ID.
+         *
+         * @param id - The UUID of the BAA.
+         * @param options - Optional request options.
+         * @returns The matching `BusinessAssociateAgreement`.
+         *
+         * @example
+         * ```typescript
+         * const baa = await client.compliance.businessAssociateAgreements.get('baa-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<BusinessAssociateAgreement>;
+        /**
+         * Create a new business associate agreement.
+         *
+         * @param attributes - BAA attributes (associate name, terms, effective date, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `BusinessAssociateAgreement`.
+         *
+         * @example
+         * ```typescript
+         * const baa = await client.compliance.businessAssociateAgreements.create({
+         *   associate_name: 'Cloud Storage Inc.',
+         *   effective_date: '2026-01-01',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<BusinessAssociateAgreement>;
+        /**
+         * Update a business associate agreement.
+         *
+         * @param id - The UUID of the BAA to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `BusinessAssociateAgreement`.
+         *
+         * @example
+         * ```typescript
+         * const baa = await client.compliance.businessAssociateAgreements.update(
+         *   'baa-uuid', { terms: 'Updated terms...' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<BusinessAssociateAgreement>;
+        /**
+         * Sign a business associate agreement.
+         *
+         * Records the signing event with timestamp and signer identity.
+         *
+         * @param id - The UUID of the BAA to sign.
+         * @param attributes - Optional signing attributes.
+         * @param options - Optional request options.
+         * @returns The updated `BusinessAssociateAgreement` with signed status.
+         *
+         * @example
+         * ```typescript
+         * const baa = await client.compliance.businessAssociateAgreements.sign('baa-uuid');
+         * ```
+         */
+        sign: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<BusinessAssociateAgreement>;
+        /**
+         * Terminate a business associate agreement.
+         *
+         * Ends the BAA relationship. Records termination date and reason.
+         *
+         * @param id - The UUID of the BAA to terminate.
+         * @param attributes - Optional termination attributes (reason, effective date).
+         * @param options - Optional request options.
+         * @returns The updated `BusinessAssociateAgreement` with terminated status.
+         *
+         * @example
+         * ```typescript
+         * const baa = await client.compliance.businessAssociateAgreements.terminate(
+         *   'baa-uuid', { reason: 'Contract not renewed.' },
+         * );
+         * ```
+         */
+        terminate: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<BusinessAssociateAgreement>;
+    };
+    /**
+     * Policy Review Schedules — track periodic policy review cycles.
+     *
+     * Regulatory frameworks require periodic review of compliance policies.
+     * Schedules track when reviews are due, overdue, or completed.
+     */
+    policyReviewSchedules: {
+        /**
+         * List policy review schedules with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `PolicyReviewSchedule` records.
+         *
+         * @example
+         * ```typescript
+         * const schedules = await client.compliance.policyReviewSchedules.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<PolicyReviewSchedule[]>;
+        /**
+         * Retrieve a single policy review schedule by ID.
+         *
+         * @param id - The UUID of the policy review schedule.
+         * @param options - Optional request options.
+         * @returns The matching `PolicyReviewSchedule`.
+         *
+         * @example
+         * ```typescript
+         * const schedule = await client.compliance.policyReviewSchedules.get('prs-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<PolicyReviewSchedule>;
+        /**
+         * Create a new policy review schedule.
+         *
+         * @param attributes - Schedule attributes (policy reference, frequency, next review date).
+         * @param options - Optional request options.
+         * @returns The newly created `PolicyReviewSchedule`.
+         *
+         * @example
+         * ```typescript
+         * const schedule = await client.compliance.policyReviewSchedules.create({
+         *   policy_name: 'Data Retention Policy',
+         *   review_frequency_days: 365,
+         *   next_review_date: '2027-01-01',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<PolicyReviewSchedule>;
+        /**
+         * Mark a policy review as completed.
+         *
+         * @param id - The UUID of the policy review schedule.
+         * @param attributes - Optional completion attributes (reviewer, notes).
+         * @param options - Optional request options.
+         * @returns The updated `PolicyReviewSchedule`.
+         *
+         * @example
+         * ```typescript
+         * const schedule = await client.compliance.policyReviewSchedules.completeReview(
+         *   'prs-uuid', { reviewer: 'compliance-officer-uuid' },
+         * );
+         * ```
+         */
+        completeReview: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<PolicyReviewSchedule>;
+        /**
+         * Mark a policy review schedule as due.
+         *
+         * @param id - The UUID of the policy review schedule.
+         * @param attributes - Optional attributes.
+         * @param options - Optional request options.
+         * @returns The updated `PolicyReviewSchedule`.
+         *
+         * @example
+         * ```typescript
+         * const schedule = await client.compliance.policyReviewSchedules.markDue('prs-uuid');
+         * ```
+         */
+        markDue: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<PolicyReviewSchedule>;
+        /**
+         * Mark a policy review schedule as overdue.
+         *
+         * @param id - The UUID of the policy review schedule.
+         * @param attributes - Optional attributes.
+         * @param options - Optional request options.
+         * @returns The updated `PolicyReviewSchedule`.
+         *
+         * @example
+         * ```typescript
+         * const schedule = await client.compliance.policyReviewSchedules.markOverdue('prs-uuid');
+         * ```
+         */
+        markOverdue: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<PolicyReviewSchedule>;
+    };
+    /**
+     * Compliance Requirements — regulatory requirements tracking.
+     *
+     * Track individual requirements from regulatory frameworks (HIPAA, GDPR,
+     * PCI DSS, SOC 2). Each requirement can be created, updated with
+     * implementation status, and deleted when no longer applicable.
+     */
+    complianceRequirements: {
+        /**
+         * List compliance requirements with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ComplianceRequirement` records.
+         *
+         * @example
+         * ```typescript
+         * const requirements = await client.compliance.complianceRequirements.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ComplianceRequirement[]>;
+        /**
+         * Retrieve a single compliance requirement by ID.
+         *
+         * @param id - The UUID of the compliance requirement.
+         * @param options - Optional request options.
+         * @returns The matching `ComplianceRequirement`.
+         *
+         * @example
+         * ```typescript
+         * const req = await client.compliance.complianceRequirements.get('cr-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ComplianceRequirement>;
+        /**
+         * Create a new compliance requirement.
+         *
+         * @param attributes - Requirement attributes (framework, control ID, description, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `ComplianceRequirement`.
+         *
+         * @example
+         * ```typescript
+         * const req = await client.compliance.complianceRequirements.create({
+         *   framework: 'hipaa',
+         *   control_id: '164.312(a)(1)',
+         *   description: 'Access Control — Unique User Identification',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceRequirement>;
+        /**
+         * Update a compliance requirement.
+         *
+         * @param id - The UUID of the compliance requirement to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `ComplianceRequirement`.
+         *
+         * @example
+         * ```typescript
+         * const req = await client.compliance.complianceRequirements.update(
+         *   'cr-uuid', { status: 'implemented' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceRequirement>;
+        /**
+         * Delete a compliance requirement.
+         *
+         * @param id - The UUID of the compliance requirement to delete.
+         * @param options - Optional request options.
+         * @returns `true` on successful deletion.
+         *
+         * @example
+         * ```typescript
+         * await client.compliance.complianceRequirements.delete('cr-uuid');
+         * ```
+         */
+        delete: (id: string, options?: RequestOptions) => Promise<true>;
+    };
+    /**
+     * Compliance Requirement Completions — evidence of requirement fulfillment.
+     *
+     * Each completion record links a compliance requirement to the evidence
+     * or action that satisfies it. Read-only once created — completions
+     * serve as an immutable audit trail.
+     */
+    complianceRequirementCompletions: {
+        /**
+         * List compliance requirement completions with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ComplianceRequirementCompletion` records.
+         *
+         * @example
+         * ```typescript
+         * const completions = await client.compliance.complianceRequirementCompletions.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ComplianceRequirementCompletion[]>;
+        /**
+         * Retrieve a single compliance requirement completion by ID.
+         *
+         * @param id - The UUID of the completion record.
+         * @param options - Optional request options.
+         * @returns The matching `ComplianceRequirementCompletion`.
+         *
+         * @example
+         * ```typescript
+         * const completion = await client.compliance.complianceRequirementCompletions.get('crc-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ComplianceRequirementCompletion>;
+        /**
+         * Create a new compliance requirement completion record.
+         *
+         * @param attributes - Completion attributes (requirement ID, evidence, completed by, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `ComplianceRequirementCompletion`.
+         *
+         * @example
+         * ```typescript
+         * const completion = await client.compliance.complianceRequirementCompletions.create({
+         *   compliance_requirement_id: 'cr-uuid',
+         *   evidence: 'Access controls verified via penetration test report.',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceRequirementCompletion>;
+    };
+    /**
+     * Compliance Officer Designations — track designated compliance officers.
+     *
+     * Regulatory frameworks require organizations to designate compliance
+     * officers (e.g., HIPAA Privacy Officer, DPO under GDPR). Designations
+     * can be created and revoked.
+     */
+    complianceOfficerDesignations: {
+        /**
+         * List compliance officer designations with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `ComplianceOfficerDesignation` records.
+         *
+         * @example
+         * ```typescript
+         * const designations = await client.compliance.complianceOfficerDesignations.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<ComplianceOfficerDesignation[]>;
+        /**
+         * Retrieve a single compliance officer designation by ID.
+         *
+         * @param id - The UUID of the designation.
+         * @param options - Optional request options.
+         * @returns The matching `ComplianceOfficerDesignation`.
+         *
+         * @example
+         * ```typescript
+         * const designation = await client.compliance.complianceOfficerDesignations.get('cod-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<ComplianceOfficerDesignation>;
+        /**
+         * Create a new compliance officer designation.
+         *
+         * @param attributes - Designation attributes (user ID, role, framework, effective date).
+         * @param options - Optional request options.
+         * @returns The newly created `ComplianceOfficerDesignation`.
+         *
+         * @example
+         * ```typescript
+         * const designation = await client.compliance.complianceOfficerDesignations.create({
+         *   user_id: 'user-uuid',
+         *   role: 'privacy_officer',
+         *   framework: 'hipaa',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceOfficerDesignation>;
+        /**
+         * Revoke a compliance officer designation.
+         *
+         * @param id - The UUID of the designation to revoke.
+         * @param attributes - Optional revocation attributes (reason, effective date).
+         * @param options - Optional request options.
+         * @returns The updated `ComplianceOfficerDesignation` with revoked status.
+         *
+         * @example
+         * ```typescript
+         * const designation = await client.compliance.complianceOfficerDesignations.revoke(
+         *   'cod-uuid', { reason: 'Role reassigned.' },
+         * );
+         * ```
+         */
+        revoke: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<ComplianceOfficerDesignation>;
+    };
+    /**
+     * ePHI Assets — electronic Protected Health Information asset inventory.
+     *
+     * HIPAA requires covered entities to maintain an inventory of systems
+     * and locations where ePHI is created, received, maintained, or
+     * transmitted. Each asset record documents one such system.
+     */
+    ephiAssets: {
+        /**
+         * List ePHI assets with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `EphiAsset` records.
+         *
+         * @example
+         * ```typescript
+         * const assets = await client.compliance.ephiAssets.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<EphiAsset[]>;
+        /**
+         * Retrieve a single ePHI asset by ID.
+         *
+         * @param id - The UUID of the ePHI asset.
+         * @param options - Optional request options.
+         * @returns The matching `EphiAsset`.
+         *
+         * @example
+         * ```typescript
+         * const asset = await client.compliance.ephiAssets.get('ea-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<EphiAsset>;
+        /**
+         * Create a new ePHI asset record.
+         *
+         * @param attributes - Asset attributes (name, type, location, custodian, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `EphiAsset`.
+         *
+         * @example
+         * ```typescript
+         * const asset = await client.compliance.ephiAssets.create({
+         *   name: 'Patient Records Database',
+         *   asset_type: 'database',
+         *   location: 'us-east-1',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<EphiAsset>;
+        /**
+         * Update an ePHI asset record.
+         *
+         * @param id - The UUID of the ePHI asset to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `EphiAsset`.
+         *
+         * @example
+         * ```typescript
+         * const asset = await client.compliance.ephiAssets.update(
+         *   'ea-uuid', { custodian: 'new-admin-uuid' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<EphiAsset>;
+    };
+    /**
+     * ePHI Data Flows — document how ePHI moves between systems.
+     *
+     * HIPAA requires understanding how ePHI flows between systems, people,
+     * and organizations. Each data flow record documents one movement path,
+     * including source, destination, and safeguards.
+     */
+    ephiDataFlows: {
+        /**
+         * List ePHI data flows with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `EphiDataFlow` records.
+         *
+         * @example
+         * ```typescript
+         * const flows = await client.compliance.ephiDataFlows.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<EphiDataFlow[]>;
+        /**
+         * Retrieve a single ePHI data flow by ID.
+         *
+         * @param id - The UUID of the ePHI data flow.
+         * @param options - Optional request options.
+         * @returns The matching `EphiDataFlow`.
+         *
+         * @example
+         * ```typescript
+         * const flow = await client.compliance.ephiDataFlows.get('edf-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<EphiDataFlow>;
+        /**
+         * Create a new ePHI data flow record.
+         *
+         * @param attributes - Data flow attributes (source, destination, data types, encryption, etc.).
+         * @param options - Optional request options.
+         * @returns The newly created `EphiDataFlow`.
+         *
+         * @example
+         * ```typescript
+         * const flow = await client.compliance.ephiDataFlows.create({
+         *   source_asset_id: 'ea-source-uuid',
+         *   destination_asset_id: 'ea-dest-uuid',
+         *   data_types: ['patient_records'],
+         *   encryption: 'tls_1_3',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<EphiDataFlow>;
+        /**
+         * Update an ePHI data flow record.
+         *
+         * @param id - The UUID of the ePHI data flow to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `EphiDataFlow`.
+         *
+         * @example
+         * ```typescript
+         * const flow = await client.compliance.ephiDataFlows.update(
+         *   'edf-uuid', { encryption: 'aes_256' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<EphiDataFlow>;
+    };
+    /**
+     * Breach Notification Artifacts — regulatory notification documents.
+     *
+     * When a breach requires notification to authorities or individuals,
+     * artifacts capture the notification letters, forms, and evidence
+     * packages. Artifacts can be drafted, updated, and sent.
+     */
+    breachNotificationArtifacts: {
+        /**
+         * List breach notification artifacts with optional pagination.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `BreachNotificationArtifact` records.
+         *
+         * @example
+         * ```typescript
+         * const artifacts = await client.compliance.breachNotificationArtifacts.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<BreachNotificationArtifact[]>;
+        /**
+         * Retrieve a single breach notification artifact by ID.
+         *
+         * @param id - The UUID of the artifact.
+         * @param options - Optional request options.
+         * @returns The matching `BreachNotificationArtifact`.
+         *
+         * @example
+         * ```typescript
+         * const artifact = await client.compliance.breachNotificationArtifacts.get('bna-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<BreachNotificationArtifact>;
+        /**
+         * Create a new breach notification artifact.
+         *
+         * @param attributes - Artifact attributes (breach ID, type, content, recipients).
+         * @param options - Optional request options.
+         * @returns The newly created `BreachNotificationArtifact`.
+         *
+         * @example
+         * ```typescript
+         * const artifact = await client.compliance.breachNotificationArtifacts.create({
+         *   breach_incident_id: 'bi-uuid',
+         *   artifact_type: 'notification_letter',
+         *   content: 'Dear affected individual...',
+         * });
+         * ```
+         */
+        create: (attributes: Record<string, unknown>, options?: RequestOptions) => Promise<BreachNotificationArtifact>;
+        /**
+         * Update a breach notification artifact.
+         *
+         * @param id - The UUID of the artifact to update.
+         * @param attributes - Attribute map of fields to change.
+         * @param options - Optional request options.
+         * @returns The updated `BreachNotificationArtifact`.
+         *
+         * @example
+         * ```typescript
+         * const artifact = await client.compliance.breachNotificationArtifacts.update(
+         *   'bna-uuid', { content: 'Revised notification...' },
+         * );
+         * ```
+         */
+        update: (id: string, attributes: Record<string, unknown>, options?: RequestOptions) => Promise<BreachNotificationArtifact>;
+        /**
+         * Send a breach notification artifact to its recipients.
+         *
+         * Triggers delivery of the notification and records the send event.
+         *
+         * @param id - The UUID of the artifact to send.
+         * @param attributes - Optional send attributes (delivery method, etc.).
+         * @param options - Optional request options.
+         * @returns The updated `BreachNotificationArtifact` with sent status.
+         *
+         * @example
+         * ```typescript
+         * const artifact = await client.compliance.breachNotificationArtifacts.send('bna-uuid');
+         * ```
+         */
+        send: (id: string, attributes?: Record<string, unknown>, options?: RequestOptions) => Promise<BreachNotificationArtifact>;
+    };
+};
+//# sourceMappingURL=compliance.d.ts.map