import { BaseClient, type BaseClientConfig } from "./base-client";
export declare class GptAdmin extends BaseClient {
    /** Agent management, versioning, training, and field templates */
    readonly agents: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Agent[]>;
        listSystemAgents: (params?: import("./namespaces/agents").ListSystemAgentsParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").SystemAgentSummary[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        getBySlug: (slug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        clone: (id: string, attributes: import("./namespaces/agents").CloneAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        cloneForWorkspace: (agentId: string, targetWorkspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        create: (attributes: import("./namespaces/agents").CreateAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        update: (id: string, attributes: import("./namespaces/agents").UpdateAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        export: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").AgentExportBundle>;
        import: (data: import("./namespaces/agents").AgentExportBundle, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        test: (id: string, attributes: import("./namespaces/agents").TestAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentTestResult>;
        validate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        teach: (id: string, attributes: import("./namespaces/agents").TeachAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Agent>;
        publishVersion: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
        restoreVersion: (id: string, attributes: import("./namespaces/agents").RestoreVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
        analyzeTraining: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingAnalytics>;
        usage: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentUsage>;
        usageAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentUsage[]>;
        stats: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentStats>;
        trainingStats: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentTrainingStats>;
        versions: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            create: (attributes: import("./namespaces/agents").CreateAgentVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            addSystemField: (id: string, fieldName: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            removeSystemField: (id: string, fieldName: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            setSystemFields: (id: string, fieldNames: string[], options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            metrics: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentStats>;
            revisions: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersionRevision[]>;
            getRevision: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersionRevision>;
            listAllRevisions: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersionRevision[]>;
            compare: (versionAId: string, versionBId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersionComparison>;
            schemaVersions: {
                list: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion[]>;
                create: (agentId: string, attributes: import("./namespaces/agents").CreateSchemaVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
                activate: (agentId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
                update: (agentId: string, versionId: string, attributes: import("./namespaces/agents").UpdateSchemaVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentVersion>;
            };
        };
        training: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample>;
            create: (attributes: import("./namespaces/agents").CreateTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample>;
            update: (id: string, attributes: import("./namespaces/agents").UpdateTrainingExampleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            bulkCreate: (agentId: string, examples: import("./namespaces/agents").CreateTrainingExampleAttributes[], options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample[]>;
            bulkDelete: (agentId: string, ids: string[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/agents").BulkDeleteResult>;
            search: (agentId: string, query: string, limit?: number, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample[]>;
            listForAgent: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingExample[]>;
            deleteForAgent: (agentId: string, exampleId: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            sessions: {
                list: (agentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingSession[]>;
                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingSession>;
                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            };
        };
        fieldTemplates: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").FieldTemplate[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FieldTemplate>;
            create: (attributes: import("./namespaces/agents").CreateFieldTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").FieldTemplate>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        deployments: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment>;
            acceptUpdate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentDeployment>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        workspaceConfigs: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").WorkspaceAgentConfig>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        souls: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").AgentSoul[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentSoul>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentSoul>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").AgentSoul>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        toolCatalog: {
            list: (options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>[]>;
        };
    };
    /** ISV application management — create, configure, and manage platform applications */
    readonly applications: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Application[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        getBySlug: (slug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        getCurrent: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/applications").CurrentApplicationResult>;
        getMe: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/applications").CurrentApplicationResult>;
        create: (attrs: import("./namespaces/applications").CreateApplicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        update: (id: string, attrs: import("./namespaces/applications").UpdateApplicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        updateComplianceTags: (id: string, complianceTags: string[], options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        grantCredits: (id: string, amount: number, tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        allocateCredits: (id: string, amount: number, description?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        provision: (spec: import("./namespaces/applications").ApplicationProvisionSpec, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/applications").ApplicationProvisionResult>;
    };
    /** Billing account management */
    readonly accounts: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Account[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Account>;
        credit: (id: string, amount: number, description?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Account>;
        debit: (id: string, amount: number, description?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Account>;
    };
    /** Platform capability catalog (admin view — full catalog, no app annotations) */
    readonly capabilities: {
        list: (options?: import("./namespaces/capabilities").ListCapabilitiesOptions) => Promise<import("./namespaces/capabilities").AdminBundleCatalog>;
        listForApplication: (options?: import("./namespaces/capabilities").ListCapabilitiesOptions) => Promise<import("./namespaces/capabilities").AnnotatedBundleCatalog>;
        get: (key: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/capabilities").Bundle | null>;
    };
    /** API key management */
    readonly apiKeys: {
        list: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        rotate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        create: (attributes: import("./namespaces/apiKeys").CreateApiKeyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        update: (id: string, attributes: import("./namespaces/apiKeys").UpdateApiKeyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        setBudget: (id: string, creditLimit: number | null, creditLimitPeriod: "daily" | "weekly" | "monthly" | "yearly" | "lifetime" | null, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
        usageStats: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import("./namespaces/apiKeys").ApiKeyUsageStat[]>;
        usageStatsAll: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/apiKeys").ApiKeyUsageStat[]>;
        active: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
        activeAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey[]>;
        resetBudgetPeriod: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ApiKey>;
    };
    /** Agent execution management and streaming */
    readonly executions: {
        start(agentId: string, input: Record<string, unknown>, opts?: {
            workspace_id?: string;
            model_id?: string;
            file_inputs?: import("./namespaces/executions").FileInput[];
        } & import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution>;
        estimate(agentId: string, input: Record<string, unknown>, opts?: {
            workspace_id
            /** Campaign management across all workspaces */
            ?: string;
        } & import("./base-client").RequestOptions): Promise<import("./namespaces/executions").ExecutionEstimate>;
        list(opts?: {
            workspace_id?: string;
        } & import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution[]>;
        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution>;
        stream(id: string, options?: import("./base-client").RequestOptions & import("./streaming").StreamOptions): Promise<AsyncIterableIterator<import("./execution-events").ExecutionEvent>>;
        approve(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution>;
        deny(id: string, reason: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution>;
        cancel(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution>;
        children(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").Execution[]>;
        tree(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/executions").ExecutionTreeNode>;
    };
    /** Storage operations and bucket management */
    readonly storage: {
        stats: (workspaceId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageStats[]>;
        buckets: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Bucket[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Bucket>;
            stats: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Bucket>;
        };
        files: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            confirmUpload: (id: string, attributes?: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            softDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            tag: (id: string, tags: string[], options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            updateMetadata: (id: string, newMetadata: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile>;
            byChecksum: (checksum: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile[]>;
            listChildren: (parentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageFile[]>;
            requestDownloadUrl: (id: string, params?: {
                expires_in?: number;
            }, options?: import("./base-client").RequestOptions) => Promise<{
                url: string;
                expires_at: string;
            }>;
        };
        recommendations: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").StorageRecommendation[]>;
            listPending: (options?: import("./base-client").RequestOptions) => Promise<import(".").StorageRecommendation[]>;
            accept: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageRecommendation>;
            dismiss: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").StorageRecommendation>;
        };
    };
    /** User management across all tenants */
    readonly users: {
        list: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import(".").User[]>;
        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").User[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        getByEmail: (email: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        update: (id: string, attributes: import("./namespaces/users").UpdateUserAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        adminUpdate: (id: string, attributes: import("./namespaces/users").AdminUpdateUserAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        adminUpdateEmail: (id: string, email: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        confirmEmail: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        triggerPasswordReset: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        registerViaInvitation: (email: string, password: string, passwordConfirmation: string, invitationToken: string, attrs?: {
            first_name?: string;
            last_name?: string;
        }, options?: import("./base-client").RequestOptions) => Promise<import(".").User>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
    };
    /** Voice session, recording, and transcription management */
    readonly voice: {
        sessions: {
            list: (options?: {
                page?: number;
                pageSize?: number;
                status?: "active" | "ended" | "failed" | "timed_out";
                insertedAfter?: string;
                insertedBefore?: string;
            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceSession[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceSession>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceSession[]>;
            issueParticipantToken: (id: string, params: import("./namespaces/voice").VoiceParticipantTokenOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/voice").VoiceParticipantTokenResult>;
            removeParticipant: (id: string, participantIdentity: string, options?: import("./base-client").RequestOptions) => Promise<void>;
        };
        recordings: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording>;
            bySession: (sessionId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceRecording[]>;
        };
        transcriptionResults: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult>;
            bySession: (sessionId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").VoiceTranscriptionResult[]>;
        };
        transcriptionJobs: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob>;
            listMine: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob[]>;
            create: (data?: import("./namespaces/voice").TranscriptionJobCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").TranscriptionJob>;
            destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
        };
    };
    /** Compliance audit log access — paginated listing, activity feeds, aggregates, and bulk exports */
    readonly audit: {
        list(params?: import("./namespaces/audit").AuditListParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/audit").AuditLog[]>;
        activityFeed(params: import("./namespaces/audit").ActivityFeedParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/audit").AuditLog[]>;
        countByAction(params: import("./namespaces/audit").CountByActionParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/audit").CountByActionResult[]>;
        requestExport(params: import("./namespaces/audit").ExportParams, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/audit").ExportResult>;
    };
    /** Webhook configuration and delivery management */
    readonly webhooks: {
        configs: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig[]>;
            create: (attributes: import("./namespaces/webhooks-ns").CreateWebhookConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            update: (id: string, attributes: import("./namespaces/webhooks-ns").UpdateWebhookConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            test: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            rotateSecret: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            bulkEnable: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<{
                success: boolean;
                count: number;
            }>;
            bulkDisable: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<{
                success: boolean;
                count: number;
            }>;
            replay: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookConfig>;
            stats: (options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            listEvents: (id: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
        };
        listEventTypes: (options?: import("./base-client").RequestOptions) => Promise<Array<{
            type: string;
            description: string;
            data_object: string;
        }>>;
        deliveries: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookDelivery[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookDelivery>;
            retry: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WebhookDelivery>;
            bulkRetry: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<{
                success: boolean;
                count: number;
            }>;
        };
    };
    /** AI content generation — text, images, tone rewriting, hashtags, SEO */
    readonly content: {
        generateText: (attributes: {
            prompt: string;
            workspace_id: string;
            brand_identity_id?: string;
            task?: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        generateImage: (attributes: {
            prompt: string;
            workspace_id: string;
            style?: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        editImage: (attributes: {
            image_url: string;
            instructions: string;
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        rewriteTone: (attributes: {
            text: string;
            target_tone: string;
            workspace_id: string;
            max_length?: number;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        shorten: (attributes: {
            text: string;
            max_chars: number;
            workspace_id: string;
            platform?: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        refine: (attributes: {
            text: string;
            instructions: string;
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        suggestTopics: (attributes: {
            workspace_id: string;
            industry? /** Cases domain: operational case aggregate, state machine workflow, decisions, links */: string;
            brand_identity_id?: string;
            count?: number;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        generateImagePrompt: (attributes: {
            marketing_copy: string;
            workspace_id: string;
            style?: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        generateHashtags: (attributes: {
            text: string;
            platform: string;
            workspace_id: string;
            industry?: string;
            count?: number;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        seoEnrich: (attributes: {
            text: string;
            target_keywords: string[];
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
    };
    /** Campaign management across all workspaces */
    readonly campaigns: {
        campaigns: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").Campaign[]>;
            create: (attributes: import("./namespaces/campaigns").CreateCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            send: (id: string, attributes?: import("./namespaces/campaigns").SendCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            analyze: (id: string, attributes?: import("./namespaces/campaigns").AnalyzeCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/campaigns").CampaignAnalysisResult>;
            optimizeSendTimes: (id: string, attributes?: import("./namespaces/campaigns").OptimizeSendTimesAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            createFollowup: (id: string, attributes: import("./namespaces/campaigns").CreateFollowupCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Campaign>;
            importRecipients: (id: string, attributes: {
                csv_storage_key: string;
                column_mapping?: Record<string, string>;
                workspace_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            generateEmails: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            optimizeSubjects: (id: string, attributes: import("./namespaces/campaigns").OptimizeSubjectsAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            export: (id: string, attributes: import("./namespaces/campaigns").ExportCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        templates: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate[]>;
            create: (attributes: import("./namespaces/campaigns").CreateTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            publish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            unpublish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            rollback: (id: string, versionNumber: number, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            preview: (id: string, variables: Record<string, string>, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingTemplate>;
            compile: (mjml: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/campaigns").MjmlCompileResult>;
            versions: (templateId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailTemplateVersion[]>;
            getVersion: (templateId: string, versionNumber: number, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailTemplateVersion>;
        };
        generatedEmails: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateGeneratedEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail>;
            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail>;
            reject: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail>;
            schedule: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail>;
            listByCampaign: (campaignId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingGeneratedEmail[]>;
        };
        sequences: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            create: (attributes: import("./namespaces/campaigns").CreateSequenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateSequenceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence[]>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            activate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            complete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequence>;
        };
        recipients: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingRecipient>;
            listByCampaign: (campaignId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingRecipient[]>;
        };
        sequenceSteps: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequenceStep>;
            create: (attributes: import("./namespaces/campaigns").CreateSequenceStepAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequenceStep>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateSequenceStepAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequenceStep>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listBySequence: (sequenceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSequenceStep[]>;
        };
        socialCampaigns: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign>;
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign[]>;
            create: (attributes: import("./namespaces/campaigns").CreateSocialCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign>;
            update: (id: string, attributes: import("./namespaces/campaigns").UpdateSocialCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            schedule: (id: string, attributes: import("./namespaces/campaigns").ScheduleSocialCampaignAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SocialCampaign>;
            generateMasterCopy: (id: string, attributes: import("./namespaces/campaigns").GenerateMasterCopyAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            adaptForPlatforms: (id: string, attributes: import("./namespaces/campaigns").AdaptForPlatformsAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            previewAdaptations: (id: string, attributes: import("./namespaces/campaigns").PreviewAdaptationsAttributes, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
        };
    };
    /** Outbound email and sender profile management across all workspaces */
    readonly email: {
        outboundEmails: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail[]>;
            listByContact: (workspaceId: string, contactRefId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail[]>;
            create: (attributes: import("./namespaces/email").CreateOutboundEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            composeWithAi: (attributes: import("./namespaces/email").ComposeWithAiAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            update: (id: string, attributes: import("./namespaces/email").UpdateOutboundEmailAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            send: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            schedule: (id: string, attributes: {
                scheduled_for: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
            cancelSchedule: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailOutboundEmail>;
        };
        senderProfiles: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile[]>;
            create: (attributes: import("./namespaces/email").CreateSenderProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile>;
            update: (id: string, attributes: import("./namespaces/email").UpdateSenderProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            validateDns: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile>;
            setDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailMarketingSenderProfile>;
        };
        recipients: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailRecipient>;
            create: (attributes: import("./namespaces/email").CreateRecipientAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailRecipient>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listByEmail: (outboundEmailId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailRecipient[]>;
        };
        inclusions: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInclusion>;
            create: (attributes: import("./namespaces/email").CreateInclusionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInclusion>;
            update: (id: string, attributes: import("./namespaces/email").UpdateInclusionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInclusion>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listByEmail: (outboundEmailId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInclusion[]>;
        };
        trackingEvents: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailTrackingEvent>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailTrackingEvent[]>;
        };
        unsubscribers: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailUnsubscriber>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EmailUnsubscriber[]>;
        };
        sendLimits: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/email").EmailSendLimit>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import("./namespaces/email").EmailSendLimit[]>;
        };
        inbound: {
            addresses: {
                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                create: (attributes: import("./namespaces/email").CreateInboundAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                update: (id: string, attributes: import("./namespaces/email").UpdateInboundAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
                rotateToken: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                disable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                enable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress>;
                listByWorkspace: (workspaceId: string, options?: {
                    page?: number;
                    pageSize?: number;
                } & import("./base-client").RequestOptions) => Promise<import(".").EmailInboundAddress[]>;
            };
            received: {
                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EmailInboundEmail>;
                listByAddress: (addressId: string, options?: {
                    page?: number;
                    pageSize?: number;
                } & import("./base-client").RequestOptions) => Promise<import(".").EmailInboundEmail[]>;
                listByWorkspace: (workspaceId: string, options?: {
                    page?: number;
                    pageSize?: number;
                } & import("./base-client").RequestOptions) => Promise<import(".").EmailInboundEmail[]>;
            };
        };
    };
    /** Tenant wallet management — credit adjustments, plan changes, usage history */
    readonly billing: {
        wallet: {
            get: (options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
            changePlan: (walletId: string, planSlug: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
            adjustCredits: (walletId: string, packageSlug: string, paymentMethodId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
            getUsage: (tenantId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Wallet>;
        };
        plans: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Plan[]>;
            get: (planId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            create: (attrs: import("./namespaces/billing").CreatePlanAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            update: (planId: string, attrs: import("./namespaces/billing").UpdatePlanAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            delete: (planId: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            deprecatePlan: (planId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            scheduleSunset: (planId: string, sunsetAt: string, replacementPlanId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            archivePlan: (planId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Plan>;
            listPlansByLifecycleStatus: (applicationId: string, lifecycleStatus?: "active" | "deprecated" | "sunset_pending" | "archived", options?: import("./base-client").RequestOptions) => Promise<import(".").Plan[]>;
        };
        pricingStrategies: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").PricingStrategy[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PricingStrategy>;
            create: (attrs: import("./namespaces/billing").CreatePricingStrategyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PricingStrategy>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreatePricingStrategyAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").PricingStrategy>;
        };
        tenantPricingOverrides: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").TenantPricingOverride[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TenantPricingOverride>;
            create: (attrs: import("./namespaces/billing").CreateTenantPricingOverrideAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").TenantPricingOverride>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreateTenantPricingOverrideAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").TenantPricingOverride>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        wholesaleAgreements: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").WholesaleAgreement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").WholesaleAgreement>;
            create: (attrs: import("./namespaces/billing").CreateWholesaleAgreementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").WholesaleAgreement>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreateWholesaleAgreementAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").WholesaleAgreement>;
            grantSignupCredits: (id: string, credits: number, reason?: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").SignupGrantStatus>;
            getSignupGrantStatus: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").SignupGrantStatus>;
        };
        isvPricingOverrides: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").IsvPricingOverride[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").IsvPricingOverride>;
            create: (attrs: import("./namespaces/billing").CreateIsvPricingOverrideAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").IsvPricingOverride>;
            update: (id: string, attrs: import("./namespaces/billing").UpdateIsvPricingOverrideAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").IsvPricingOverride>;
        };
        settlementStatements: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").SettlementStatement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SettlementStatement>;
            markPaid: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SettlementStatement>;
            markReconciled: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SettlementStatement>;
            markDisputed: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SettlementStatement>;
        };
        settlements: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Settlement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Settlement>;
            create: (attrs: import("./namespaces/billing").CreateSettlementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Settlement>;
        };
        accounts: {
            grantCredits: (applicationId: string, opts: {
                amount: number;
                tenant_id: string;
                description?: string | null;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Application>;
        };
        featureDefinitions: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition[]>;
            create: (attrs: import("./namespaces/billing").CreateFeatureDefinitionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreateFeatureDefinitionAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureDefinition>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        planFeatureAllocations: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation>;
            listByPlan: (planId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation[]>;
            create: (attrs: import("./namespaces/billing").CreatePlanFeatureAllocationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreatePlanFeatureAllocationAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").PlanFeatureAllocation>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        featureUsages: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage>;
            listByTenant: (tenantId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").FeatureUsage[]>;
        };
        usageEvents: {
            list: (tenantId: string, filters?: {
                startDate?: string;
                endDate?: string;
                page?: number;
                pageSize?: number;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").UsageEvent[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UsageEvent>;
            listByUser: (tenantId: string, userId: string, filters?: {
                startDate?: string;
                endDate?: string;
                page?: number;
                pageSize?: number;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").UsageEvent[]>;
            summary: (tenantId: string, filters?: {
                startDate?: string;
                endDate?: string;
                page?: number;
                pageSize?: number;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").UsageEvent[]>;
        };
        estimateCapacity: (params: {
            creditBudget: number;
            operationsMix: Array<{
                operationKey: string;
                weight: number;
            }>;
        }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").EstimateCapacityResponse>;
        compositeOperations: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").CompositeOperation[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CompositeOperation>;
            create: (attrs: import("./namespaces/billing").CreateCompositeOperationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CompositeOperation>;
            update: (id: string, attrs: Partial<import("./namespaces/billing").CreateCompositeOperationAttributes>, options?: import("./base-client").RequestOptions) => Promise<import(".").CompositeOperation>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        planBundles: {
            publish: (bundle: import("./namespaces/billing").PlanBundleSpec, opts?: import("./namespaces/billing").PlanBundlePublishOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").PlanBundlePublishResult>;
            previewEconomics: (bundle: import("./namespaces/billing").PlanBundleSpec, mix?: import("./namespaces/billing").PlanBundleMix, options?: import("./base-client").RequestOptions) => Promise<{
                [key: string]: unknown;
            }>;
            listTemplates: (filter?: {
                vertical?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").PlanBundleTemplate[]>;
            canEnable: (args: {
                applicationId: string;
                capabilityKey: string;
                planSlug?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").CanEnableResult>;
        };
        capabilityRevocations: {
            previewCascade: (applicationId: string, capability: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/billing").CapabilityRevocationPreview>;
        };
        subscriptions: {
            listCapabilityRevoked: (filters?: {
                applicationId?: string;
                capability?: string;
                includeCanceled?: boolean;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Subscription[]>;
            listSubscriptionsByPlanRevision: (planId: string, revisionId?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Subscription[]>;
            setRateLimitOverrides: (subscriptionId: string, overrides: {
                rate_limit_requests_override?: number | null;
                rate_limit_period_seconds_override?: number | null;
                concurrent_operations_limit_override?: number | null;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").Subscription>;
        };
    };
    /** Portal management: invitations, change request review */
    readonly portal: {
        invitations: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalInvitation[]>;
            create: (email: string, tenantId: string, invitedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalInvitation>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
        };
        changeRequests: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalChangeRequest[]>;
            approve: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalChangeRequest>;
            reject: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/portal").PortalChangeRequest>;
        };
    };
    /** Social media accounts, posts, metrics, and AI-powered campaigns */
    readonly social: {
        accounts: {
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByPlatform: (platform: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/social").SocialAccountCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/social").SocialAccountUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            enablePosting: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            disablePosting: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        posts: {
            create: (attributes: import("./namespaces/social").SocialPostCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/social").SocialPostUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            schedule: (id: string, scheduledAt: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            publishNow: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            retry: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            updateSeo: (id: string, attributes: {
                seo_score?: number;
                seo_analysis?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listScheduled: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByAccount: (socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByCampaign: (socialCampaignId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        metrics: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByPost: (socialPostId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            latestForPost: (socialPostId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            byAccount: (socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            byCampaign: (socialCampaignId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        campaigns: {
            list: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (workspaceId: string, attributes: import("./namespaces/social").SocialCampaignCreateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/social").SocialCampaignUpdateAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            schedule: (id: string, scheduledAt: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            generateMasterCopy: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            adaptForPlatforms: (id: string, workspaceId: string, socialAccountId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            previewAdaptations: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        trending: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: {
                workspace_id: string;
                enrichment_level?: "raw" | "scored" | "summarized" | "full";
                query?: string;
                source_breakdown?: Record<string, unknown>;
                item_count?: number;
                fetched_at?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByDateRange: (from: string, to: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            items: {
                get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
                listBySnapshot: (snapshotId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            };
        };
        watches: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: {
                workspace_id: string;
                name: string;
                query: string;
                sources?: string[];
                conditions?: Record<string, unknown>;
                notification_config?: Record<string, unknown>;
                enabled?: boolean;
            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: {
                name?: string;
                query?: string;
                sources?: string[];
                conditions?: Record<string, unknown>;
                notification_config?: Record<string, unknown>;
                enabled?: boolean;
            }, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            markTriggered: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
    };
    /** Connector management: instances, credentials, OAuth configs, ISV tools */
    readonly connectors: {
        instances: {
            list: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConnectorInstance[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConnectorInstance>;
            create: (attributes: import("./namespaces/connectors").CreateConnectorInstanceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ConnectorInstance>;
            update: (id: string, attributes: import("./namespaces/connectors").UpdateConnectorInstanceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ConnectorInstance>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        credentials: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Credential[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Credential>;
            refresh: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Credential>;
        };
        sync: {
            logs: (options?: import("./base-client").RequestOptions) => Promise<import(".").SyncLog[]>;
            log: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SyncLog>;
        };
        oauth: {
            connect: (connectorType: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<{
                auth_url: string;
                state: string;
            }>;
            callback: (connectorType: string, code: string, state: string, workspaceId: string, redirectUri?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConnectorInstance>;
        };
        oauthAppConfigs: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").OauthAppConfig[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").OauthAppConfig>;
            create: (attributes: import("./namespaces/connectors").CreateOAuthAppConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").OauthAppConfig>;
            update: (id: string, attributes: import("./namespaces/connectors").UpdateOAuthAppConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").OauthAppConfig>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        tools: {
            list: (connectorId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool[]>;
            get: (connectorId: string, toolId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool>;
            create: (connectorId: string, attributes: import("./namespaces/connectors").CreateConnectorToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool>;
            update: (connectorId: string, toolId: string, attributes: import("./namespaces/connectors").UpdateConnectorToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool>;
            delete: (connectorId: string, toolId: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            activate: (connectorId: string, toolId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool>;
            deactivate: (connectorId: string, toolId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool>;
            test: (connectorId: string, toolId: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            import: (connectorId: string, spec: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/connectors").ConnectorTool[]>;
        };
    };
    /** Web crawling, content extraction, and site configuration management */
    readonly crawler: {
        jobs: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerJob[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerJob>;
            create: (attributes: import("./namespaces/crawler").AdminCreateCrawlerJobAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerJob>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerJob>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        schedules: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            create: (attributes: import("./namespaces/crawler").AdminCreateCrawlerScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            update: (id: string, attributes: import("./namespaces/crawler").AdminUpdateCrawlerScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            enable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            disable: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            trigger: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSchedule>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        results: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerResult[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerResult>;
        };
        siteConfigs: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSiteConfig[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSiteConfig>;
            create: (attributes: import("./namespaces/crawler").AdminCreateSiteConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSiteConfig>;
            update: (id: string, attributes: import("./namespaces/crawler").AdminUpdateSiteConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CrawlerSiteConfig>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        newsMonitors: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            create: (attributes: import("./namespaces/crawler").CreateNewsMonitorAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            update: (id: string, attributes: import("./namespaces/crawler").UpdateNewsMonitorAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsMonitor>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        newsSummaries: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").NewsSummary[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").NewsSummary>;
        };
        browserSessions: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").BrowserSession[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrowserSession>;
            create: (attributes: import("./namespaces/crawler").AdminCreateBrowserSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BrowserSession>;
            refresh: (id: string, attributes: import("./namespaces/crawler").AdminRefreshBrowserSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BrowserSession>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
    };
    /** Scheduling: locations, event types, events, participants, bookings, availability, reminders, calendar syncs */
    readonly scheduling: {
        locations: {
            list: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation[]>;
            listByType: (type: "venue" | "room" | "virtual" | "resource", options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingLocationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingLocationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation>;
            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingLocation>;
        };
        eventTypes: {
            list: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingEventTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingEventTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType>;
            getBySlug: (slug: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEventType>;
        };
        events: {
            list: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            cancel: (id: string, attributes?: import("./namespaces/scheduling").CancelAdminSchedulingEventAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            complete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            reschedule: (id: string, attributes: {
                new_start_time: string;
                new_end_time: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent>;
            listByDateRange: (workspaceId: string, startTime: string, endTime: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent[]>;
            listByParticipant: (email: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingEvent[]>;
        };
        participants: {
            list: (eventId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingParticipant[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingParticipant>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingParticipantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingParticipant>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingParticipantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingParticipant>;
            respond: (id: string, status: "accepted" | "declined" | "tentative", options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingParticipant>;
            remove: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        availabilityRules: {
            list: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingAvailabilityRuleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingAvailabilityRuleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule>;
            destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listByUser: (userId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule[]>;
            listByEventType: (eventTypeId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingAvailabilityRule[]>;
        };
        bookings: {
            list: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            confirm: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            cancel: (id: string, attributes?: import("./namespaces/scheduling").CancelAdminSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            reschedule: (id: string, attributes: import("./namespaces/scheduling").RescheduleAdminSchedulingBookingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            markNoShow: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking>;
            listByBooker: (email: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingBooking[]>;
        };
        reminders: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingReminder[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingReminder>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingReminderAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingReminder>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingReminder>;
        };
        calendarSyncs: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync>;
            create: (attributes: import("./namespaces/scheduling").CreateAdminSchedulingCalendarSyncAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync>;
            update: (id: string, attributes: import("./namespaces/scheduling").UpdateAdminSchedulingCalendarSyncAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync>;
            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync>;
            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchedulingCalendarSync>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
    };
    /** CRM management — contacts, companies, deals, pipelines, ISV entity type and field configuration */
    readonly crm: {
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        listArchived: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        create: (attributes: import("./namespaces/crm").CreateCrmContactAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        update: (id: string, attributes: import("./namespaces/crm").UpdateCrmContactAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        unarchive: (id: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        companies: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmCompanyAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCompanyAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        deals: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmDealAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmDealAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            moveStage: (id: string, attributes: import("./namespaces/crm").MoveDealStageAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        activities: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmActivityAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmActivityAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        pipelines: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmPipelineAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmPipelineAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        pipelineStages: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByPipeline: (pipelineId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmPipelineStageAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmPipelineStageAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        relationships: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmRelationshipAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        relationshipTypes: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            list: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmRelationshipTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmRelationshipTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        customEntities: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmCustomEntityAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCustomEntityAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listVersions: (entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            getVersion: (entityId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        dealProducts: {
            list: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmDealProductAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        exports: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmDataExportAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            refreshUrl: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        entityTypes: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmCustomEntityTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCustomEntityTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        fieldDefinitions: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntityType: (entityType: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmCustomFieldDefinitionAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmCustomFieldDefinitionAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        channelCaptureConfig: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmChannelCaptureConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmChannelCaptureConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        syncConfigs: {
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmSyncConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmSyncConfigAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        addresses: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            setPrimary: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntity: (entityType: "contact" | "company", entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        phoneNumbers: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmPhoneNumberAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmPhoneNumberAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            setPrimary: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntity: (entityType: "contact" | "company", entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        emailAddresses: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmEmailAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmEmailAddressAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            setPrimary: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntity: (entityType: "contact" | "company", entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        socialProfiles: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmSocialProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmSocialProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntity: (entityType: "contact" | "company", entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        websites: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: import("./namespaces/crm").CreateCrmWebsiteAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: import("./namespaces/crm").UpdateCrmWebsiteAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            setPrimary: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByEntity: (entityType: "contact" | "company", entityId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        graph: {
            paths(params: import("./namespaces/crm").CrmGraphPathsParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
            related(params: import("./namespaces/crm").CrmGraphRelatedParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
            strength(params: import("./namespaces/crm").CrmGraphStrengthParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
        };
        ai: {
            stagedExtractions(workspaceId: string, options?: {
                entity_type?: string;
                status?: string;
            } & import("./base-client").RequestOptions): Promise<unknown>;
            approveExtraction(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
            rejectExtraction(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
            duplicates(workspaceId: string, options?: {
                entity_type?: string;
                status?: string;
            } & import("./base-client").RequestOptions): Promise<unknown>;
            mergeContacts(params: import("./namespaces/crm").CrmMergeParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
            mergeCompanies(params: import("./namespaces/crm").CrmMergeParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
            search(params: import("./namespaces/crm").CrmSearchParams, options?: import("./base-client").RequestOptions): Promise<unknown>;
            forecast(workspaceId: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        };
        bulkTransferOwnership: (resourceType: "contacts" | "deals" | "companies" | "custom-entities", params: {
            workspace_id: string;
            resource_ids: string[];
            owner_id?: string | null;
        }, options?: import("./base-client").RequestOptions) => Promise<{
            transferred: number;
            owner_id: string | null;
            failed?: number;
        }>;
    };
    /** Extraction pipeline: documents, results, batches, exports, workflows, analysis */
    readonly extraction: {
        documents: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            view: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            status: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            updateStatus: (id: string, attributes: import("./namespaces/extraction").UpdateDocumentStatusAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            reprocess: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            dismiss: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            exclude: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            include: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            updateVerification: (id: string, attributes: import("./namespaces/extraction").UpdateDocumentVerificationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            markTrained: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            dismissTraining: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            finishUpload: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            beginUpload: (attributes: import("./namespaces/extraction").AdminBeginUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PresignedUrl>;
            findOrBeginUpload: (attributes: import("./namespaces/extraction").AdminFindOrBeginUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PresignedUrl>;
            presignedUpload: (attributes: import("./namespaces/extraction").AdminPresignedUploadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PresignedUrl>;
            upload: (attributes: import("./namespaces/extraction").AdminUploadDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument>;
            bulkReprocess: (attrs: import("./namespaces/extraction").AdminBulkReprocessAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").OperationSuccess>;
            bulkDelete: (ids: string[], options?: import("./base-client").RequestOptions) => Promise<import(".").OperationSuccess>;
            stats: (options?: import("./base-client").RequestOptions) => Promise<import(".").DocumentStats>;
            workspaceThroughput: (workspaceId: string, window?: import("./namespaces/extraction").AdminWorkspaceThroughputWindow, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").AdminWorkspaceThroughput>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            listByStatus: (workspaceId: string, status: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            reviewQueue: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            listTrained: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            listTrashed: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            listExcluded: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionDocument[]>;
            dismissAllTrained: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").OperationSuccess>;
        };
        results: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult>;
            update: (id: string, attributes: import("./namespaces/extraction").AdminUpdateResultAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            byDocument: (documentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult[]>;
            history: (documentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult[]>;
            partial: (documentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult[]>;
            regenerate: (id: string, attributes: import("./namespaces/extraction").AdminRegenerateResultAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult>;
            saveCorrections: (id: string, attributes: import("./namespaces/extraction").AdminSaveCorrectionsAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionResult[]>;
        };
        batches: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionBatch>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            create: (attributes: import("./namespaces/extraction").AdminCreateBatchAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionBatch>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionBatch[]>;
            getUploadUrls: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PresignedUrl[]>;
            finishAll: (batchId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/extraction").AdminBatchFinishAllResult>;
        };
        exports: {
            list: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionExport[]>;
            create: (workspaceId: string, attributes: import("./namespaces/extraction").AdminCreateExportAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionExport>;
            get: (workspaceId: string, id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionExport>;
        };
        workflows: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionWorkflow[]>;
            create: (attributes: import("./namespaces/extraction").AdminCreateWorkflowAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionWorkflow>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionWorkflow>;
            update: (id: string, attributes: import("./namespaces/extraction").AdminUpdateWorkflowAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionWorkflow>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        configEnums: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ConfigEnum[]>;
            create: (attributes: import("./namespaces/extraction").AdminCreateConfigEnumAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ConfigEnum>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConfigEnum>;
            update: (id: string, attributes: import("./namespaces/extraction").AdminUpdateConfigEnumAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ConfigEnum>;
        };
        schemaDiscoveries: {
            create: (attributes: import("./namespaces/extraction").AdminCreateSchemaDiscoveryAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchemaDiscovery>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SchemaDiscovery>;
            bootstrap: (attributes: import("./namespaces/extraction").AdminBootstrapSchemaDiscoveryAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SchemaDiscovery>;
        };
        fieldMappings: {
            get: (workspaceId: string, documentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").FieldMappingResult>;
            create: (workspaceId: string, documentId: string, attributes: import("./namespaces/extraction").AdminFieldMappingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").FieldMappingResult>;
        };
        shadowComparisons: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ShadowComparison[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ShadowComparison>;
            create: (attributes: import("./namespaces/extraction").AdminCreateShadowComparisonAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ShadowComparison>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            analysis: (options?: import("./base-client").RequestOptions) => Promise<import(".").ShadowComparison[]>;
        };
        analyses: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionAnalysis[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionAnalysis>;
        };
        postProcessingHooks: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").PostProcessingHook[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PostProcessingHook>;
            create: (attributes: import("./namespaces/extraction").AdminCreatePostProcessingHookAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PostProcessingHook>;
            update: (id: string, attributes: import("./namespaces/extraction").AdminUpdatePostProcessingHookAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PostProcessingHook>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        trainingAnalytics: {
            forWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingAnalytics>;
            batch: (workspaceIds: string, options?: import("./base-client").RequestOptions) => Promise<import(".").TrainingAnalytics[]>;
        };
        extractionAgents: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionAgent[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ExtractionAgent>;
            predict: (attributes: import("./namespaces/extraction").AdminPredictExtractionAgentAttributes, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        chunkEntityLinks: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ChunkEntityLink[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChunkEntityLink>;
            byDocument: (documentId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChunkEntityLink[]>;
            byChunk: (documentChunkId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChunkEntityLink[]>;
            byEntity: (graphNodeId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChunkEntityLink[]>;
        };
    };
    /** Support domain: tickets, queues, SLA policies, routing, AI config, canned responses */
    readonly support: {
        tickets: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            assign: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            resolve: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            close: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            reopen: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            merge: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        messages: {
            listByTicket: (ticketId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        attachments: {
            listByMessage: (messageId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        ratings: {
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        tags: {
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        queues: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        queueMembers: {
            listByQueue: (queueId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        routingRules: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        slaPolicies: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            listByApplication: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        aiConfig: {
            getForWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            upsert: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        channelCaptureConfig: {
            getForWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            upsert: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
        syncConfig: {
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        cannedResponses: {
            listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            create: (attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            update: (id: string, attributes: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<unknown>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
    };
    /** Cases domain: operational case aggregate, state machine workflow, decisions, links */
    readonly cases: {
        cases: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").Case[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            attentionList: (workspaceId: string, options?: import("./namespaces/cases").AdminCaseAttentionListOptions) => Promise<import(".").Case[]>;
            attentionSummary: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/cases").AdminCaseAttentionSummary>;
            create: (attributes: import("./namespaces/cases").CreateCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            update: (id: string, attributes: import("./namespaces/cases").UpdateCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            transitionState: (id: string, attributes: import("./namespaces/cases").TransitionCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            assignOwner: (id: string, attributes: import("./namespaces/cases").AssignCaseOwnerAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            decide: (id: string, attributes: import("./namespaces/cases").DecideCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            reopen: (id: string, attributes?: import("./namespaces/cases").ReopenCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            close: (id: string, attributes?: import("./namespaces/cases").CloseCaseAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Case>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        caseTypes: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").CaseType[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseType>;
            create: (attributes: import("./namespaces/cases").CreateCaseTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseType>;
            update: (id: string, attributes: import("./namespaces/cases").UpdateCaseTypeAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseType>;
            activate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseType>;
            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseType>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        documents: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").CaseDocumentLink[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseDocumentLink>;
            create: (attributes: import("./namespaces/cases").CreateCaseDocumentLinkAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseDocumentLink>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        entities: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").CaseEntityLink[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseEntityLink>;
            create: (attributes: import("./namespaces/cases").CreateCaseEntityLinkAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CaseEntityLink>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        pipelines: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").CasePipelineLink[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CasePipelineLink>;
        };
    };
    /** Contracts domain: AI contract lifecycle, clauses, renewal alerts (capability: contract_tracking) */
    readonly contracts: {
        contracts: {
            list: (options?: {
                page
                /** Billing account management */
                ?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").Contract[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Contract>;
            create: (attributes: import("./namespaces/contracts").CreateContractAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Contract>;
            update: (id: string, attributes: import("./namespaces/contracts").UpdateContractAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Contract>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        clauses: {
            listForContract: (contractId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ContractClause[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ContractClause>;
        };
        renewalAlerts: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ContractRenewalAlert[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ContractRenewalAlert>;
        };
    };
    /** Meetings domain: AI meeting intelligence — meetings, transcripts, action items (capability: meeting_intelligence) */
    readonly meetings: {
        meetings: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").Meeting[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Meeting>;
            create: (attributes: import("./namespaces/meetings").CreateMeetingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Meeting>;
            update: (id: string, attributes: import("./namespaces/meetings").UpdateMeetingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Meeting>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        transcripts: {
            list: (options?: {
                page?: number;
                pageSize?: number;
                includePhi?: boolean;
            } & import("./base-client").RequestOptions) => Promise<import(".").MeetingTranscript[]>;
            get: (id: string, options?: import("./base-client").RequestOptions & {
                includePhi?: boolean;
            }) => Promise<import(".").MeetingTranscript>;
        };
        actionItems: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").MeetingActionItem[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").MeetingActionItem>;
        };
    };
    /** Reviews domain: human review queues, memberships, and lifecycle transitions */
    readonly reviews: {
        reviews: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").Review[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            assign: (id: string, attributes: import("./namespaces/reviews").AdminAssignReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            claim: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            unclaim: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            approve: (id: string, attributes?: import("./namespaces/reviews").AdminApproveReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            reject: (id: string, attributes?: import("./namespaces/reviews").AdminRejectReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            correct: (id: string, attributes?: import("./namespaces/reviews").AdminCorrectReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
            escalate: (id: string, attributes: import("./namespaces/reviews").AdminEscalateReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Review>;
        };
        queues: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ReviewQueue[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ReviewQueue>;
            summaries: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/reviews").AdminReviewQueueSummary[]>;
            create: (attributes: import("./namespaces/reviews").AdminCreateReviewQueueAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ReviewQueue>;
            update: (id: string, attributes: import("./namespaces/reviews").AdminUpdateReviewQueueAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ReviewQueue>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        memberships: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ReviewQueueMembership[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ReviewQueueMembership>;
            create: (attributes: import("./namespaces/reviews").AdminCreateReviewQueueMembershipAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ReviewQueueMembership>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
    };
    /** Model catalog — available models with tier classification */
    readonly models: {
        list(options?: import("./namespaces/models").ListModelsOptions, reqOptions?: import("./base-client").RequestOptions): Promise<import("./namespaces/models").ModelInfo[]>;
        get(modelId: string, reqOptions?: import("./base-client").RequestOptions): Promise<import("./namespaces/models").ModelInfo>;
    };
    /** AI/LLM management — provider configs, analytics, semantic cache */
    readonly ai: {
        providerConfig: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").ProviderConfig[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").ProviderConfig>;
            create: (attributes: Partial<import("./namespaces/ai").ProviderConfig>, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").ProviderConfig>;
            update: (id: string, attributes: Partial<import("./namespaces/ai").ProviderConfig>, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").ProviderConfig>;
        };
        analytics: {
            list: (options?: import("./base-client").RequestOptions) => Promise<import(".").LlmAnalytics[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LlmAnalytics>;
            record: (attributes: import("./namespaces/ai").RecordLlmAnalyticsAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").LlmAnalytics>;
            costs: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").LlmCostBreakdown>;
            summary: (params?: {
                startDate?: string;
                endDate?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").LlmAnalyticsSummary>;
            usage: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").LlmAnalyticsUsage>;
            workspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").LlmWorkspaceMetrics>;
            platformSummary: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/ai").LlmPlatformSummary>;
        };
        cache: {
            stats: (options?: import("./base-client").RequestOptions) => Promise<unknown>;
            clear: (confirm: boolean, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        };
    };
    /** CRM cluster discovery — AI-labeled relationship clusters via community detection */
    readonly crmClusters: {
        discover(workspaceId: string): Promise<import("./namespaces/crm-clusters").CrmCluster[]>;
    };
    /** Compliance scanning — PII/PHI detection and redaction (HIPAA Safe Harbor) */
    readonly compliance: {
        scan(text: string): Promise<import("./namespaces/compliance").ScanResult>;
        legalDocuments: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").LegalDocument[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument>;
            create: (attributes: import("./namespaces/compliance").CreateLegalDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateLegalDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            byLocale: (locale: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument[]>;
            forApplication: (options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument[]>;
            publish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument>;
            unpublish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalDocument>;
        };
        compliancePolicies: {
            list: (applicationId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CompliancePolicy[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CompliancePolicy>;
            create: (attributes: import("./namespaces/compliance").CreateCompliancePolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CompliancePolicy>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateCompliancePolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CompliancePolicy>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        getPosture: (params: {
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/compliance").CompliancePosture>;
        scanResults: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ScanResult[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ScanResult>;
        };
        accessLogs: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").AccessLog[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AccessLog>;
        };
        auditChainEntries: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").AuditChainEntry[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AuditChainEntry>;
        };
        disclosureLogs: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").DisclosureLog[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").DisclosureLog>;
            listBySubject: (subjectType: string, subjectId: string, options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").DisclosureLog[]>;
            create: (attributes: import("./namespaces/compliance").CreateDisclosureLogAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DisclosureLog>;
        };
        consentRecords: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ConsentRecord[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConsentRecord>;
            listActive: (userId: string, options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ConsentRecord[]>;
            grant: (attributes: import("./namespaces/compliance").GrantConsentRecordAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ConsentRecord>;
            withdraw: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ConsentRecord>;
        };
        legalAcceptances: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").LegalAcceptance[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").LegalAcceptance>;
            listLatest: (userId: string, documentType: import("./namespaces/compliance").LegalDocumentAcceptanceType, options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").LegalAcceptance[]>;
        };
        processingActivities: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ProcessingActivity[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ProcessingActivity>;
            create: (attributes: import("./namespaces/compliance").CreateProcessingActivityAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ProcessingActivity>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        impactAssessments: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").DataProtectionImpactAssessment[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").DataProtectionImpactAssessment>;
            create: (attributes: import("./namespaces/compliance").CreateImpactAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataProtectionImpactAssessment>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateImpactAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataProtectionImpactAssessment>;
            approve: (id: string, attributes?: import("./namespaces/compliance").ApproveImpactAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataProtectionImpactAssessment>;
        };
        dataTransferRecords: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").DataTransferRecord[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").DataTransferRecord>;
            create: (attributes: import("./namespaces/compliance").CreateDataTransferRecordAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataTransferRecord>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        breachNotifications: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").BreachNotification[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachNotification>;
        };
        breachNotificationArtifacts: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").BreachNotificationArtifact[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachNotificationArtifact>;
            create: (attributes: import("./namespaces/compliance").CreateBreachNotificationArtifactAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachNotificationArtifact>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateBreachNotificationArtifactAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachNotificationArtifact>;
            send: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachNotificationArtifact>;
        };
        businessAssociateAgreements: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement>;
            create: (attributes: import("./namespaces/compliance").CreateBusinessAssociateAgreementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateBusinessAssociateAgreementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement>;
            sign: (id: string, attributes?: import("./namespaces/compliance").SignBusinessAssociateAgreementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement>;
            terminate: (id: string, attributes?: import("./namespaces/compliance").TerminateBusinessAssociateAgreementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BusinessAssociateAgreement>;
        };
        amendmentRequests: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
            create: (attributes: import("./namespaces/compliance").CreateAmendmentRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
            review: (id: string, attributes?: import("./namespaces/compliance").ReviewAmendmentRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
            deny: (id: string, attributes?: import("./namespaces/compliance").DenyAmendmentRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
            applyAmendment: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").AmendmentRequest>;
        };
        ephiAssets: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EphiAsset[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiAsset>;
            create: (attributes: import("./namespaces/compliance").CreateEphiAssetAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiAsset>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateEphiAssetAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiAsset>;
        };
        ephiDataFlows: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").EphiDataFlow[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiDataFlow>;
            create: (attributes: import("./namespaces/compliance").CreateEphiDataFlowAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiDataFlow>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateEphiDataFlowAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").EphiDataFlow>;
        };
        policyReviewSchedules: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule>;
            create: (attributes: import("./namespaces/compliance").CreatePolicyReviewScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule>;
            completeReview: (id: string, attributes?: import("./namespaces/compliance").CompletePolicyReviewAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule>;
            markDue: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule>;
            markOverdue: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PolicyReviewSchedule>;
        };
        complianceDocumentTemplates: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ComplianceDocumentTemplate[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceDocumentTemplate>;
            create: (attributes: import("./namespaces/compliance").CreateComplianceDocumentTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceDocumentTemplate>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateComplianceDocumentTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceDocumentTemplate>;
            clone: (attributes: import("./namespaces/compliance").CloneComplianceDocumentTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceDocumentTemplate>;
        };
        complianceOfficerDesignations: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ComplianceOfficerDesignation[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceOfficerDesignation>;
            create: (attributes: import("./namespaces/compliance").CreateComplianceOfficerDesignationAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceOfficerDesignation>;
            revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceOfficerDesignation>;
        };
        complianceRequirements: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirement>;
            create: (attributes: import("./namespaces/compliance").CreateComplianceRequirementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirement>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateComplianceRequirementAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirement>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        complianceRequirementCompletions: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirementCompletion[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirementCompletion>;
            create: (attributes: import("./namespaces/compliance").CreateComplianceRequirementCompletionAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ComplianceRequirementCompletion>;
        };
        cdeScopeReports: {
            list: (options?: {
                filter?: Record<string, unknown>;
                sort?: string;
                include?: string;
                fields?: Record<string, unknown>;
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").CdeScopeReport[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").CdeScopeReport>;
            create: (attributes: import("./namespaces/compliance").CreateCdeScopeReportAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").CdeScopeReport>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        breachIncidents: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").BreachIncident[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachIncident>;
            create: (attributes: import("./namespaces/compliance").CreateBreachIncidentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachIncident>;
            updateStatus: (id: string, attributes: import("./namespaces/compliance").UpdateBreachIncidentStatusAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BreachIncident>;
        };
        dataSubjectRequests: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").DataSubjectRequest[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").DataSubjectRequest>;
            create: (attributes: import("./namespaces/compliance").CreateDataSubjectRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataSubjectRequest>;
            updateStatus: (id: string, attributes: import("./namespaces/compliance").UpdateDataSubjectRequestStatusAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").DataSubjectRequest>;
        };
        retentionPolicies: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").RetentionPolicy[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").RetentionPolicy>;
            create: (attributes: import("./namespaces/compliance").CreateRetentionPolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").RetentionPolicy>;
            update: (id: string, attributes: import("./namespaces/compliance").UpdateRetentionPolicyAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").RetentionPolicy>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        riskAssessments: {
            list: (options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import(".").RiskAssessment[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").RiskAssessment>;
            create: (attributes: import("./namespaces/compliance").CreateRiskAssessmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").RiskAssessment>;
            updateStatus: (id: string, attributes: import("./namespaces/compliance").UpdateRiskAssessmentStatusAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").RiskAssessment>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
    };
    /** Agent pipeline management — create, configure, and trigger multi-node agent pipelines */
    readonly pipelines: {
        list(options?: import("./base-client").RequestOptions): Promise<unknown>;
        get(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        getBySlug(slug: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        create(attributes: import("./namespaces/pipelines").CreatePipelineAttributes, options?: import("./base-client").RequestOptions): Promise<unknown>;
        update(id: string, attributes: import("./namespaces/pipelines").UpdatePipelineAttributes, options?: import("./base-client").RequestOptions): Promise<unknown>;
        delete(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        listByWorkflowType(workflowType: "build" | "troubleshoot" | "security_scan" | "analyze" | "evaluate" | "custom", options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipelines").Pipeline[]>;
        trigger(id: string, attributes: import("./namespaces/pipelines").TriggerPipelineAttributes, options?: import("./base-client").RequestOptions): Promise<unknown>;
    };
    /** Pipeline execution management — HITL checkpoint lifecycle (approve, reject, edit, refine) */
    readonly pipelineExecutions: {
        get(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        list(workspaceId: string, filters?: {
            status?: import("./namespaces/pipeline-executions").PipelineExecutionStatus;
        }, options?: import("./base-client").RequestOptions): Promise<unknown>;
        approve(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        reject(id: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        updateCheckpoint(id: string, attributes: import("./namespaces/pipeline-executions").UpdateCheckpointAttributes, options?: import("./base-client").RequestOptions): Promise<unknown>;
        addNote(id: string, note: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
        aiRefine(id: string, nodeId: string, instruction: string, options?: import("./base-client").RequestOptions): Promise<unknown>;
    };
    /** Pipeline node management — create, update, delete, and query individual pipeline nodes */
    readonly pipelineNodes: {
        list(options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-nodes").PipelineNode[]>;
        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-nodes").PipelineNode>;
        listByPipeline(pipelineId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-nodes").PipelineNode[]>;
        create(attributes: import("./namespaces/pipeline-nodes").CreatePipelineNodeAttributes, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-nodes").PipelineNode>;
        update(id: string, attributes: import("./namespaces/pipeline-nodes").UpdatePipelineNodeAttributes, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-nodes").PipelineNode>;
        delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
    };
    /** Pipeline node execution tracking — per-node execution status and output data */
    readonly pipelineNodeExecutions: {
        get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-node-executions").PipelineNodeExecution>;
        listByExecution(pipelineExecutionId: string, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/pipeline-node-executions").PipelineNodeExecution[]>;
    };
    /** Tenant lifecycle management — suspend, unsuspend, cancel */
    readonly tenants: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        create: (attributes: import("./namespaces/tenants").CreateTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        update: (id: string, attributes: import("./namespaces/tenants").UpdateTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
        credit: (id: string, amount: number, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        schedulePurge: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        verifyStorage: (id: string, _options?: import("./base-client").RequestOptions) => Promise<{
            tenant_id: string;
            status: "ok" | "partial";
            buckets: Array<{
                name: string;
                type: "public" | "private" | "processing";
                db_ok: boolean;
                gcs_ok: boolean;
            }>;
        }>;
        transferOwnership: (id: string, newOwnerId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        updateBranding: (id: string, attributes: import("./namespaces/tenants").UpdateBrandingAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        updateAutoTopUp: (id: string, attributes: import("./namespaces/tenants").UpdateAutoTopUpAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        convertToOrg: (id: string, attributes: import("./namespaces/tenants").ConvertToOrgAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        createOrg: (attributes: import("./namespaces/tenants").CreateOrgTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        createPersonal: (_attributes?: import("./namespaces/tenants").CreatePersonalTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        createIsv: (attributes: import("./namespaces/tenants").CreateIsvTenantAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        suspend: (id: string, reason: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        unsuspend: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        cancel: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        reactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Tenant>;
        getDocumentStats: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        getStats: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
        getWorkspaceStats: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<unknown>;
    };
    /** ReBAC access grant management — create, list, update, and revoke grants */
    readonly accessGrants: {
        list(params?: import("./namespaces/access-grants").AccessGrantListParams): Promise<import("./namespaces/access-grants").AccessGrantListResult>;
        get(id: string): Promise<import("./namespaces/access-grants").AccessGrantResult>;
        create(attrs: import(".").PostAdminAccessGrantsData["body"]): Promise<import("./namespaces/access-grants").AccessGrantResult>;
        update(id: string, attrs: import(".").PatchAdminAccessGrantsByIdData["body"]): Promise<import("./namespaces/access-grants").AccessGrantResult>;
        revoke(id: string): Promise<void>;
    };
    /** Role management — named permission bundles for workspace access control */
    readonly roles: {
        list(params?: import("./namespaces/roles").RoleListParams): Promise<import("./namespaces/roles").RoleListResult>;
        get(id: string): Promise<import("./namespaces/roles").RoleResult>;
        create(attrs: import(".").PostAdminRolesData["body"]): Promise<import("./namespaces/roles").RoleResult>;
        update(id: string, attrs: import(".").PatchAdminRolesByIdData["body"]): Promise<import("./namespaces/roles").RoleResult>;
        destroy(id: string): Promise<void>;
    };
    /** Permission registry — platform permissions, presets, and metadata */
    readonly permissions: {
        list(params?: import("./namespaces/permissions").PermissionListParams): Promise<import("./namespaces/permissions").PermissionListResult>;
        get(id: string): Promise<import("./namespaces/permissions").PermissionResult>;
        meta(): Promise<import("./namespaces/permissions").PermissionMetaResult>;
        listPresets(params?: import("./namespaces/permissions").PermissionPresetListParams): Promise<import("./namespaces/permissions").PermissionPresetListResult>;
        getPreset(id: string): Promise<import("./namespaces/permissions").PermissionPresetResult>;
    };
    /** Ownership transfer audit log — read-only workspace-scoped history */
    readonly ownershipTransfers: {
        list(params: import("./namespaces/ownership-transfers").OwnershipTransferListParams): Promise<import("./namespaces/ownership-transfers").OwnershipTransferListResult>;
    };
    /** Chat thread management — cross-workspace thread inspection, moderation, and lifecycle */
    readonly threads: {
        list: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        update: (id: string, attributes: import("./namespaces/threads").UpdateThreadAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        search: (query: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread[]>;
        archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        unarchive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        summarize: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        fork: (id: string, title?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        export: (id: string, format?: "json" | "markdown" | "text", options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        complete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThread>;
        platformStats: (options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThreadStats>;
        workspaceStats: (options?: import("./base-client").RequestOptions) => Promise<import(".").ChatThreadWorkspaceStats>;
        messages: {
            list: (threadId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage[]>;
            send: (threadId: string, content: string, attributes?: import("./namespaces/threads").SendMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ChatMessage>;
        };
    };
    /** Clinical analytics — ISV-level overview and pipeline metrics */
    readonly clinical: {
        analytics: {
            overview(workspaceId: string, params?: Record<string, string>, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/clinical").ClinicalAnalyticsOverview>;
            pipeline(workspaceId: string, params?: Record<string, string>, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/clinical").ClinicalPipelineAnalytics>;
        };
        goalTemplates: {
            list: (params: {
                workspace_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate[]>;
            listMine: (params: {
                created_by_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate[]>;
            listCategories: (params: {
                workspace_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplateCategory[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            create: (attributes: import("./namespaces/clinical").CreateGoalTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            createFromExisting: (attributes: import("./namespaces/clinical").CreateFromExistingAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateGoalTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate[]>;
            listCatalog: (params: {
                application_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate[]>;
            getCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            createCatalog: (attributes: import("./namespaces/clinical").CreateCatalogGoalTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            updateCatalog: (id: string, attributes: import("./namespaces/clinical").UpdateCatalogGoalTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            deleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            archiveCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            restoreCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate>;
            permanentDeleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchivedCatalog: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplate[]>;
            listCatalogCategories: (params: {
                application_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalGoalTemplateCategory[]>;
            tags: {
                rename: (workspaceId: string, oldTag: string, newTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagRenameResult>;
                delete: (workspaceId: string, tag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagDeleteResult>;
                merge: (workspaceId: string, sourceTags: string[], targetTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagMergeResult>;
            };
            imports: {
                fromFile: (workspaceId: string, file: File | Blob, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
                fromUrl: (workspaceId: string, url: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            };
            duplicates: {
                getStats: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateStats>;
                listGroups: (workspaceId: string, opts?: {
                    threshold?: number;
                    limit?: number;
                }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateGroup[]>;
                resolve: (workspaceId: string, groupId: string, keepId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateResolveResult>;
            };
            collections: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                list(params: {
                    workspace_id: string;
                    page?: {
                        offset?: number;
                        limit?: number;
                    };
                }, options?: import("./base-client").RequestOptions): Promise<(Omit<import(".").ClinicalGoalTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                })[]>;
                create(attrs: import("./namespaces/clinical").CreateGoalTemplateCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                update(id: string, attrs: import("./namespaces/clinical").UpdateGoalTemplateCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
                templates: {
                    get(id: string, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    list(collectionId: string, options?: import("./base-client").RequestOptions & {
                        page?: {
                            offset?: number;
                            limit?: number;
                        };
                    }): Promise<(Omit<import(".").ClinicalGoalTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    })[]>;
                    create(attrs: import("./namespaces/clinical").CreateCollectionMembershipAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    update(id: string, attrs: import("./namespaces/clinical").UpdateCollectionMembershipAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalGoalTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
                };
            };
        };
        noteTemplates: {
            list: (params: {
                workspace_id: string;
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate[]>;
            listMine: (params: {
                created_by_id: string;
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            create: (attributes: {
                workspace_id: string;
                note_type: "soap" | "adime" | "progress" | "discharge" | "addendum";
                title: string;
                description?: string;
                sections: Record<string, string>;
                category?: string;
                tags?: string[];
                metadata?: Record<string, unknown>;
                source_catalog_id?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            createFromExisting: (attributes: {
                workspace_id: string;
                source_template_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            update: (id: string, attributes: {
                note_type?: "soap" | "adime" | "progress" | "discharge" | "addendum";
                title?: string;
                description?: string;
                sections?: Record<string, string>;
                category?: string;
                tags?: string[];
                metadata?: Record<string, unknown>;
                is_active?: boolean;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: {
                workspace_id: string;
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate[]>;
            getCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            createCatalog: (attributes: {
                note_type: "soap" | "adime" | "progress" | "discharge" | "addendum";
                title: string;
                description?: string;
                sections: Record<string, string>;
                category?: string;
                tags?: string[];
                metadata?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            updateCatalog: (id: string, attributes: {
                note_type?: "soap" | "adime" | "progress" | "discharge" | "addendum";
                title?: string;
                description?: string;
                sections?: Record<string, string>;
                category?: string;
                tags?: string[];
                metadata?: Record<string, unknown>;
                is_active?: boolean;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            listCatalog: (params?: {
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate[]>;
            archiveCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            restoreCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate>;
            permanentDeleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchivedCatalog: (params?: {
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteTemplate[]>;
        };
        supplementTemplates: {
            list: (params: {
                workspace_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate[]>;
            listMine: (params: {
                created_by_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            create: (attributes: import("./namespaces/clinical").CreateSupplementTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            createFromExisting: (attributes: import("./namespaces/clinical").CreateFromExistingSupplementTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateSupplementTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate[]>;
            listCatalog: (params: {
                application_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate[]>;
            getCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            createCatalog: (attributes: import("./namespaces/clinical").CreateCatalogSupplementTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            updateCatalog: (id: string, attributes: import("./namespaces/clinical").UpdateCatalogSupplementTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            deleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            archiveCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            restoreCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate>;
            permanentDeleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchivedCatalog: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementTemplate[]>;
            applyToPatient: (templateId: string, patientId: string, workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ApplySupplementTemplateResponse>;
            collections: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                list(params: {
                    workspace_id: string;
                    page?: {
                        offset?: number;
                        limit?: number;
                    };
                }, options?: import("./base-client").RequestOptions): Promise<(Omit<import(".").ClinicalSupplementTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                })[]>;
                create(attrs: import("./namespaces/clinical").CreateSupplementTemplateCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                update(id: string, attrs: import("./namespaces/clinical").UpdateSupplementTemplateCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollection, "attributes" | "relationships"> & {
                    description?: string | null;
                    metadata?: {
                        [key: string]: unknown;
                    } | null;
                    name: string;
                    template_count?: number | null;
                } & {
                    [key: string]: never;
                }>;
                delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
                templates: {
                    get(id: string, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    list(collectionId: string, options?: import("./base-client").RequestOptions & {
                        page?: {
                            offset?: number;
                            limit?: number;
                        };
                    }): Promise<(Omit<import(".").ClinicalSupplementTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    })[]>;
                    create(attrs: import("./namespaces/clinical").CreateSupplementCollectionMembershipAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    update(id: string, attrs: import("./namespaces/clinical").UpdateSupplementCollectionMembershipAttributes, options?: import("./base-client").RequestOptions): Promise<Omit<import(".").ClinicalSupplementTemplateCollectionMembership, "attributes" | "relationships"> & {
                        added_at?: unknown;
                        collection_id: string;
                        sort_order?: number | null;
                        template_id: string;
                    } & {
                        [key: string]: never;
                    }>;
                    delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
                };
            };
        };
        practiceTools: {
            list: (params: {
                workspace_id: string;
                filter?: {
                    tool_type?: string;
                    category?: string;
                    is_active?: boolean;
                    [key: string]: unknown;
                };
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            create: (attributes: import("./namespaces/clinical").CreatePracticeToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdatePracticeToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool[]>;
            listCatalog: (params: {
                application_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool[]>;
            getCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            createCatalog: (attributes: import("./namespaces/clinical").CreateCatalogPracticeToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            updateCatalog: (id: string, attributes: import("./namespaces/clinical").UpdateCatalogPracticeToolAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            deleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            archiveCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            restoreCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool>;
            permanentDeleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchivedCatalog: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeTool[]>;
            listCatalogCategories: (params: {
                application_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeToolCategory[]>;
            tags: {
                rename: (workspaceId: string, oldTag: string, newTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagRenameResult>;
                delete: (workspaceId: string, tag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagDeleteResult>;
                merge: (workspaceId: string, sourceTags: string[], targetTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagMergeResult>;
            };
            imports: {
                fromFile: (workspaceId: string, file: File | Blob, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
                fromUrl: (workspaceId: string, url: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            };
            duplicates: {
                getStats: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateStats>;
                listGroups: (workspaceId: string, opts?: {
                    threshold?: number;
                    limit?: number;
                }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateGroup[]>;
                resolve: (workspaceId: string, groupId: string, keepId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateResolveResult>;
            };
        };
        practiceResources: {
            list: (params: {
                workspace_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            create: (attributes: import("./namespaces/clinical").CreatePracticeResourceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdatePracticeResourceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource[]>;
            listCatalog: (params: {
                application_id: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource[]>;
            getCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            createCatalog: (attributes: import("./namespaces/clinical").CreateCatalogPracticeResourceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            updateCatalog: (id: string, attributes: import("./namespaces/clinical").UpdateCatalogPracticeResourceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            deleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            archiveCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            restoreCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource>;
            permanentDeleteCatalog: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchivedCatalog: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPracticeResource[]>;
            listCategories: (params: {
                workspace_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").PracticeResourceCategory[]>;
            listCatalogCategories: (params: {
                application_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").PracticeResourceCategory[]>;
            tags: {
                rename: (workspaceId: string, oldTag: string, newTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagRenameResult>;
                delete: (workspaceId: string, tag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagDeleteResult>;
                merge: (workspaceId: string, sourceTags: string[], targetTag: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").TagMergeResult>;
            };
            imports: {
                fromFile: (workspaceId: string, file: File | Blob, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
                fromUrl: (workspaceId: string, url: string, options?: import("./base-client").RequestOptions) => Promise<Record<string, unknown>>;
            };
            duplicates: {
                getStats: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateStats>;
                listGroups: (workspaceId: string, opts?: {
                    threshold?: number;
                    limit?: number;
                }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateGroup[]>;
                resolve: (workspaceId: string, groupId: string, keepId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").DuplicateResolveResult>;
            };
        };
        patients: {
            list: (params: {
                workspace_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatient[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatient>;
            create: (attributes: import("./namespaces/clinical").CreateClinicalPatientAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatient>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClinicalPatientAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatient>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            goals: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal[]>;
            healthMetrics: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric[]>;
            supplements: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement[]>;
            medications: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication[]>;
            resourceAssignments: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment[]>;
            insuranceRecords: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance[]>;
        };
        sessions: {
            list: (params: {
                workspace_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSession[]>;
            listByPatient: (params: {
                patient_id: string;
                filter?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSession[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSession>;
            create: (attributes: import("./namespaces/clinical").CreateClinicalSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSession>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClinicalSessionAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSession>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            notes: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote[]>;
            mealPlans: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
        };
        notes: {
            list: (params: {
                session_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote[]>;
            listByPatient: (patientId: string, params?: {
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote[]>;
            listByWorkspace: (workspaceId: string, params?: {
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            create: (attributes: import("./namespaces/clinical").CreateClinicalNoteAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClinicalNoteAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote[]>;
            approve: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            reject: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNote>;
            cosign: (id: string, cosignedById: string, options?: import("./base-client").RequestOptions) => Promise<{
                type: "clinical-note";
                id: string;
                status: string;
                requires_cosign: boolean;
                cosigned_by_id: string | null;
                cosigned_at: string | null;
            }>;
            tag: (id: string, tags: string[], options?: import("./base-client").RequestOptions) => Promise<{
                type: "clinical-note";
                id: string;
                tags: string[];
            }>;
            fromTemplate: (attributes: {
                template_id: string;
                session_id: string;
                placeholders?: Record<string, string>;
            }, options?: import("./base-client").RequestOptions) => Promise<{
                type: "clinical-note";
                id: string;
                status: string;
                note_type: string;
                session_id: string;
                source_template_id: string;
            }>;
            diffVersions: (noteId: string, fromVersion: number, toVersion: number, options?: import("./base-client").RequestOptions) => Promise<{
                mode: "section" | "text";
                ops: unknown[];
                identical: boolean;
                from_version: number;
                to_version: number;
            }>;
            search: (attributes: {
                query: string;
                patient_id?: string;
                session_id?: string;
                limit?: number;
                min_similarity?: number;
            }, options?: import("./base-client").RequestOptions) => Promise<Array<{
                note_id: string;
                session_id: string | null;
                patient_id: string | null;
                similarity: number;
                snippet: string;
            }>>;
            versions: (noteId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteVersion[]>;
            getVersion: (noteId: string, id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalNoteVersion>;
        };
        healthMetrics: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric[]>;
            listBySession: (params: {
                session_id: string;
                filter?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            create: (attributes: import("./namespaces/clinical").CreateHealthMetricAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateHealthMetricAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric[]>;
            summary: (params: import("./namespaces/clinical").HealthMetricSummaryParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").HealthMetricSummaryPeriod[]>;
            listByType: (params: {
                patient_id: string;
                metric_type: string;
                from_date?: string;
                to_date?: string;
                filter?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalHealthMetric[]>;
        };
        intakeTargets: {
            create: (attributes: import("./namespaces/clinical").CreateIntakeTargetAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateIntakeTargetAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget>;
            listByPatient: (patientId: string, opts?: {
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget[]>;
            getActive: (patientId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget[]>;
            listByWorkspace: (params: {
                workspace_id: string;
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget[]>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (workspaceId: string, opts?: {
                page?: {
                    offset?: number;
                    limit?: number;
                };
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalIntakeTarget[]>;
        };
        mealPlans: {
            list: (params: {
                session_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
            listByWorkspace: (params: {
                workspace_id: string;
                filter?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
            listByPatient: (patientId: string, params?: {
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            create: (attributes: import("./namespaces/clinical").CreateMealPlanAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateMealPlanAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan>;
            listByMealSchedule: (mealScheduleId: string, params?: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalMealPlan[]>;
        };
        clientGoals: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            create: (attributes: import("./namespaces/clinical").CreateClientGoalAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            createFromTemplate: (attributes: import("./namespaces/clinical").CreateGoalFromTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClientGoalAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal[]>;
            batchUpdate: (updates: import("./namespaces/clinical").BatchUpdateGoalItem[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").BatchUpdateGoalResponse>;
            approve: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            reject: (id: string, reviewedById: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientGoal>;
            batchApprove: (opts: {
                goalIds: string[];
                reviewedById: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").BatchApproveGoalsResponse>;
            batchReject: (opts: {
                goalIds: string[];
                reviewedById: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").BatchRejectGoalsResponse>;
            history: (goalId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").GoalHistoryResponse>;
            associate: (goalId: string, attributes: import("./namespaces/clinical").CreateGoalAssociationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").GoalAssociation>;
            dissociate: (_goalId: string, associationId: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            getAssociation: (associationId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").GoalAssociation>;
            associations: (goalId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").GoalAssociation[]>;
            associatedGoals: (params: {
                entity_type: string;
                entity_id: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").GoalAssociation[]>;
        };
        clientSupplements: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            create: (attributes: import("./namespaces/clinical").CreateClientSupplementAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClientSupplementAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientSupplement[]>;
            bulkCreate: (attrs: {
                workspace_id: string;
                supplements: Array<Record<string, unknown>>;
            }, options?: import("./base-client").RequestOptions) => Promise<Array<{
                id?: string;
                status: string;
                error?: string;
            }>>;
            batchUpdate: (updates: import("./namespaces/clinical").BatchUpdateSupplementItem[], options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").BatchUpdateSupplementResponse>;
            checkIns: {
                create: (supplementId: string, attributes: import("./namespaces/clinical").CreateSupplementCheckInAttributes, options?: import("./base-client").RequestOptions) => Promise<{
                    data: import("./namespaces/clinical").SupplementCheckIn;
                }>;
                list: (supplementId: string, params?: import("./namespaces/clinical").ListSupplementCheckInsParams, options?: import("./base-client").RequestOptions) => Promise<{
                    data: import("./namespaces/clinical").SupplementCheckIn[];
                }>;
                update: (supplementId: string, checkInId: string, attributes: import("./namespaces/clinical").UpdateSupplementCheckInAttributes, options?: import("./base-client").RequestOptions) => Promise<{
                    data: import("./namespaces/clinical").SupplementCheckIn;
                }>;
                delete: (supplementId: string, checkInId: string, options?: import("./base-client").RequestOptions) => Promise<void>;
                batchUpsert: (supplementId: string, items: import("./namespaces/clinical").BatchSupplementCheckInItem[], options?: import("./base-client").RequestOptions) => Promise<{
                    data: import("./namespaces/clinical").BatchSupplementCheckInResponse;
                }>;
            };
        };
        insuranceAuthorizations: {
            list: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization>;
            create: (attributes: import("./namespaces/clinical").CreateInsuranceAuthorizationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateInsuranceAuthorizationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization>;
            increment: (id: string, units?: number, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization>;
            listExpiring: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization[]>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
            listByWorkspace: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalInsuranceAuthorization[]>;
        };
        patientInsurance: {
            list: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance>;
            create: (attributes: import("./namespaces/clinical").CreatePatientInsuranceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdatePatientInsuranceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
            listByWorkspace: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalPatientInsurance[]>;
        };
        clientMedications: {
            list: (params?: import("./namespaces/clinical").ClinicalListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            create: (attributes: import("./namespaces/clinical").CreateClientMedicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClientMedicationAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params?: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientMedication[]>;
            bulkCreate: (attrs: {
                workspace_id: string;
                medications: Array<Omit<import("./namespaces/clinical").CreateClientMedicationAttributes, "workspace_id">>;
            }, options?: import("./base-client").RequestOptions) => Promise<Array<{
                id?: string;
                status: string;
                error?: string;
            }>>;
        };
        deliveries: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDelivery[]>;
            listBySession: (params: {
                session_id: string;
                filter?: Record<string, unknown>;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDelivery[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDelivery>;
            create: (attributes: import("./namespaces/clinical").CreateClinicalDeliveryAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDelivery>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClinicalDeliveryAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDelivery>;
        };
        clientResourceAssignments: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            create: (attributes: import("./namespaces/clinical").CreateClientResourceAssignmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateClientResourceAssignmentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            archive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            restore: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment>;
            permanentDelete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            listArchived: (params: import("./namespaces/clinical").ClinicalWorkspaceListParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalClientResourceAssignment[]>;
        };
        supplementRecCache: {
            list: (params: {
                patient_id?: string;
                filter?: Record<string, unknown>;
                sort?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementRecCache[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementRecCache>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateSupplementRecCacheAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalSupplementRecCache>;
        };
        documents: {
            list: (params?: import("./namespaces/clinical").ListDocumentsOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument[]>;
            create: (attributes: import("./namespaces/clinical").CreateDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument>;
            update: (id: string, attributes: import("./namespaces/clinical").UpdateDocumentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<void>;
            listByPatient: (patientId: string, params?: import("./namespaces/clinical").ListDocumentsByPatientOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument[]>;
            transitionStatus: (id: string, status: import("./namespaces/clinical").ExtractionStatus, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/clinical").ClinicalDocument>;
        };
    };
    /** Workspace management — create, configure, allocate credits, storage settings */
    readonly workspaces: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        homeSnapshot: (workspaceId: string, window?: import("./namespaces/workspaces").AdminWorkspaceHomeSnapshotWindow, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/workspaces").AdminWorkspaceHomeSnapshot>;
        create: (attributes: import("./namespaces/workspaces").CreateWorkspaceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        update: (id: string, attributes: import("./namespaces/workspaces").UpdateWorkspaceAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        goLive: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        takeOffline: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        mine: (options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
        shared: (options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace[]>;
        allocateCredits: (id: string, amount: number, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        updateStorageSettings: (id: string, settings: Record<string, unknown>, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
        populateHashes: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Workspace>;
    };
    /** Invitation management — create, accept, decline, revoke, resend */
    readonly invitations: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
        create: (attributes: import("./namespaces/invitations").InviteAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        mine: (options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation[]>;
        getByToken: (token: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        acceptByToken: (token: string, email?: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        accept: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        acceptById: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        acceptByUser: (id: string, userId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        decline: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
        resend: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").Invitation>;
    };
    /** Brand identity management — create, update, set/unset default, per-tenant/workspace */
    readonly brandIdentities: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        create: (attributes: import("./namespaces/brand-identities").CreateBrandIdentityAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        update: (id: string, attributes: import("./namespaces/brand-identities").UpdateBrandIdentityAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        listByTenant: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity[]>;
        listByWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity[]>;
        getDefaultForTenant: (tenantId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        getDefaultForWorkspace: (workspaceId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        setDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
        unsetDefault: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").BrandIdentity>;
    };
    /** Platform tone management — create, update, delete, per-brand listing */
    readonly platformTones: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").PlatformTone[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlatformTone>;
        create: (attributes: import("./namespaces/platform-tones").CreatePlatformToneAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PlatformTone>;
        update: (id: string, attributes: import("./namespaces/platform-tones").UpdatePlatformToneAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").PlatformTone>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        listByBrand: (brandIdentityId: string, options?: import("./base-client").RequestOptions) => Promise<import(".").PlatformTone[]>;
    };
    /** Claimed domain management — enterprise DNS claiming, verify/revoke lifecycle */
    readonly claimedDomains: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain>;
        create: (attributes: import("./namespaces/claimed-domains").CreateClaimedDomainAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain>;
        update: (id: string, attributes: import("./namespaces/claimed-domains").UpdateClaimedDomainAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain>;
        verify: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain>;
        revoke: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").ClaimedDomain>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
    };
    /** Platform-wide system messages — ToS, privacy policy, welcome, announcements */
    readonly systemMessages: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage>;
        create: (attributes: import("./namespaces/system-messages").CreateSystemMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage>;
        update: (id: string, attributes: import("./namespaces/system-messages").UpdateSystemMessageAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage>;
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        publish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage>;
        unpublish: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").SystemMessage>;
    };
    /** HTML→PDF generation and report delivery */
    readonly documents: {
        generatePdf: (params: import("./namespaces/documents").GeneratePdfParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/documents").GeneratePdfResponse>;
        emailReport: (params: import("./namespaces/documents").EmailReportParams, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/documents").EmailReportResponse>;
    };
    /** Scoped channel tokens for WebSocket authentication */
    readonly channels: {
        authorize(request: import("./namespaces/channels").ChannelTokenRequest, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/channels").ChannelTokenResponse>;
    };
    /** Unified import hub — CSV/JSON batch imports across Clinical, CRM, and Catalog */
    readonly imports: {
        listAdapters: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/imports").ImportAdapter[]>;
        batch: (params: {
            adapter: string;
            workspace_id: string;
            rows: Record<string, unknown>[];
            metadata?: Record<string, unknown>;
        }, options?: import("./base-client").RequestOptions) => Promise<{
            import_id: string;
            status: string;
        }>;
        upload: (file: File | Blob, params: {
            adapter: string;
            workspace_id: string;
            column_mapping?: Record<string, string>;
            metadata?: Record<string, unknown>;
        }, options?: import("./base-client").RequestOptions) => Promise<{
            data: {
                import_id: string;
                status: string;
            };
        }>;
        list: (params: {
            workspace_id: string;
            adapter?: string;
            status?: string;
            offset?: number;
            limit?: number;
        }, options?: import("./base-client").RequestOptions) => Promise<import("./request-builder").ListResponse<import("./namespaces/imports").Import>>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/imports").Import>;
        rows: (importId: string, params?: {
            offset?: number;
            limit?: number;
        }, options?: import("./base-client").RequestOptions) => Promise<import("./request-builder").ListResponse<import("./namespaces/imports").ImportRow>>;
        confirm: (id: string, params: {
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<{
            import_id: string;
            status: string;
        }>;
        cancel: (id: string, params: {
            workspace_id: string;
        }, options?: import("./base-client").RequestOptions) => Promise<{
            import_id: string;
            status: string;
        }>;
    };
    /** Bidirectional invoicing — invoices, lines, payments, templates, rules, recurring schedules, contacts */
    readonly invoices: {
        invoices: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice[]>;
            create: (attributes: import("./namespaces/invoices").CreateInvoiceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateInvoiceAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            submitForApproval: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            approve: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            send: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            markViewed: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            void: (id: string, voidedReason: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            markOverdue: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            dispute: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            resolveDispute: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            schedulePayment: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            markPaid: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
            applyAiSuggestions: (id: string, acceptedKeys: string[], options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesInvoice>;
        };
        lines: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesLine>;
            create: (attributes: import("./namespaces/invoices").CreateInvoiceLineAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesLine>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateInvoiceLineAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesLine>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        payments: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesPayment>;
            create: (attributes: import("./namespaces/invoices").CreatePaymentAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesPayment>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        templates: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesTemplate>;
            create: (attributes: import("./namespaces/invoices").CreateTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesTemplate>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateTemplateAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesTemplate>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        rules: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRule>;
            create: (attributes: import("./namespaces/invoices").CreateRuleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRule>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateRuleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRule>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            deactivate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRule>;
        };
        recurringSchedules: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRecurringSchedule>;
            create: (attributes: import("./namespaces/invoices").CreateRecurringScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRecurringSchedule>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateRecurringScheduleAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRecurringSchedule>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
            pause: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRecurringSchedule>;
            resume: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesRecurringSchedule>;
        };
        contacts: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesContact>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesContact[]>;
            create: (attributes: import("./namespaces/invoices").CreateContactAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesContact>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateContactAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesContact>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        quoteRequests: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesQuoteRequest>;
            listByWorkspace: (workspaceId: string, options?: {
                page?: number;
                pageSize?: number;
            } & import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesQuoteRequest[]>;
            create: (attributes: import("./namespaces/invoices").CreateQuoteRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesQuoteRequest>;
            update: (id: string, attributes: import("./namespaces/invoices").UpdateQuoteRequestAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesQuoteRequest>;
            delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        };
        activities: {
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./_internal/types.gen").InvoicesActivity>;
        };
    };
    /** Recipe management, meal planning, shopping lists, nutrition tracking, and AI enrichment */
    readonly recipes: {
        get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        list(workspaceId: string, options?: import("./namespaces/recipes").ListOptions & {
            filter?: {
                status?: string;
                created_by?: string;
            };
        }): Promise<import(".").RecipesRecipe[]>;
        listByContact(workspaceId: string, contactId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipe[]>;
        listPublished(workspaceId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipe[]>;
        create(attrs: import("./namespaces/recipes").CreateRecipeAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        import(attrs: import("./namespaces/recipes").ImportRecipeAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        bulkImport(recipes: import("./namespaces/recipes").ImportRecipeAttributes[], options?: import("./base-client").RequestOptions): Promise<import("./namespaces/recipes").BulkImportResult>;
        update(id: string, attrs: import("./namespaces/recipes").UpdateRecipeAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        reEnrich(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        archive(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        restore(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipe>;
        delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        ingredients: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesIngredient>;
            list(recipeId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesIngredient[]>;
            create(attrs: import("./namespaces/recipes").CreateIngredientAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesIngredient>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateIngredientAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesIngredient>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        };
        foodItems: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesFoodItem>;
            list(applicationId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesFoodItem[]>;
            create(attrs: import("./namespaces/recipes").CreateFoodItemAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesFoodItem>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateFoodItemAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesFoodItem>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        };
        nutrition: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeNutrition>;
            getByRecipe(recipeId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipeNutrition[]>;
            create(attrs: import("./namespaces/recipes").CreateRecipeNutritionAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeNutrition>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateRecipeNutritionAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeNutrition>;
        };
        tags: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesTag>;
            list(applicationId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesTag[]>;
            create(attrs: import("./namespaces/recipes").CreateTagAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesTag>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateTagAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesTag>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        };
        recipeTags: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeTag>;
            listByRecipe(recipeId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipeTag[]>;
            create(attrs: import("./namespaces/recipes").CreateRecipeTagAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeTag>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        };
        favorites: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeFavorite>;
            list(workspaceId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipeFavorite[]>;
            listByRecipe(recipeId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesRecipeFavorite[]>;
            create(attrs: import("./namespaces/recipes").CreateRecipeFavoriteAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeFavorite>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateRecipeFavoriteAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeFavorite>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
        };
        collections: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeCollection>;
            list(workspaceId: string, options?: import("./namespaces/recipes").CollectionListOptions): Promise<import(".").RecipesRecipeCollection[]>;
            create(attrs: import("./namespaces/recipes").CreateRecipeCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeCollection>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateRecipeCollectionAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesRecipeCollection>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            recipes: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesCollectionRecipe>;
                list(collectionId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesCollectionRecipe[]>;
                create(attrs: import("./namespaces/recipes").CreateCollectionRecipeAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesCollectionRecipe>;
                update(id: string, attrs: import("./namespaces/recipes").UpdateCollectionRecipeAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesCollectionRecipe>;
                delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            };
        };
        enrichmentJobs: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesEnrichmentJob>;
            list(recipeId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesEnrichmentJob[]>;
        };
        mealSchedules: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesMealSchedule>;
            list(workspaceId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesMealSchedule[]>;
            create(attrs: import("./namespaces/recipes").CreateMealScheduleAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesMealSchedule>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateMealScheduleAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesMealSchedule>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            meals: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesScheduledMeal>;
                list(mealScheduleId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesScheduledMeal[]>;
                create(attrs: import("./namespaces/recipes").CreateScheduledMealAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesScheduledMeal>;
                update(id: string, attrs: import("./namespaces/recipes").UpdateScheduledMealAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesScheduledMeal>;
                delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            };
            nutritionSummaries: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesNutritionSummary>;
                list(mealScheduleId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesNutritionSummary[]>;
            };
        };
        shoppingLists: {
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingList>;
            list(workspaceId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesShoppingList[]>;
            create(attrs: import("./namespaces/recipes").CreateShoppingListAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingList>;
            update(id: string, attrs: import("./namespaces/recipes").UpdateShoppingListAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingList>;
            delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            generate(mealScheduleId: string, workspaceId: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingList>;
            regenerate(shoppingListId: string, workspaceId: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingList>;
            items: {
                get(id: string, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingListItem>;
                list(shoppingListId: string, options?: import("./namespaces/recipes").ListOptions): Promise<import(".").RecipesShoppingListItem[]>;
                create(attrs: import("./namespaces/recipes").CreateShoppingListItemAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingListItem>;
                update(id: string, attrs: import("./namespaces/recipes").UpdateShoppingListItemAttributes, options?: import("./base-client").RequestOptions): Promise<import(".").RecipesShoppingListItem>;
                delete(id: string, options?: import("./base-client").RequestOptions): Promise<void>;
            };
        };
    };
    /** Registry management — catalogs, items, versions, publishing */
    readonly registry: {
        items: {
            list: (filters?: import("./namespaces/registry").ListItemsOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            getByName: (name: string, filters?: {
                catalog_id?: string;
            }, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            create: (attributes: import("./namespaces/registry").CreateRegistryItemAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            update: (id: string, attributes: import("./namespaces/registry").UpdateRegistryItemAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            deprecate: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            versions: {
                list: (itemId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryVersion[]>;
                get: (itemId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryVersion>;
                create: (itemId: string, attributes: import("./namespaces/registry").CreateRegistryVersionAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryVersion>;
                activate: (itemId: string, versionId: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryItem>;
            };
        };
        catalogs: {
            list: (filters?: import("./namespaces/registry").ListCatalogsOptions, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryCatalog[]>;
            get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/registry").RegistryCatalog>;
        };
    };
    /** User-scoped, workspace-isolated preference storage */
    readonly preferences: {
        get(contextKey: string, options?: import("./base-client").RequestOptions): Promise<Record<string, unknown> | null>;
        upsert(contextKey: string, data: Record<string, unknown>, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/preferences").UserPreference>;
        delete(contextKey: string, options?: import("./base-client").RequestOptions): Promise<void>;
        list(opts?: {
            prefix?: string;
        }, options?: import("./base-client").RequestOptions): Promise<import("./namespaces/preferences").UserPreference[]>;
    };
    /** User profile management — CRUD, ToS acceptance, welcome/announcement dismissals */
    readonly userProfiles: {
        delete: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        list: (options?: {
            page?: number;
            pageSize?: number;
        } & import("./base-client").RequestOptions) => Promise<import(".").UserProfile[]>;
        listAll: (options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        create: (attributes: import("./namespaces/userProfiles").CreateUserProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        update: (id: string, attributes: import("./namespaces/userProfiles").UpdateUserProfileAttributes, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        me: (options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        acceptLegalDocument: (id: string, documentType: import("./namespaces/userProfiles").LegalDocumentType, version: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        dismissWelcome: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
        dismissAnnouncement: (id: string, options?: import("./base-client").RequestOptions) => Promise<import(".").UserProfile>;
    };
    /** Available API key scopes grouped by surface and namespace */
    readonly scopes: {
        list(reqOptions?: import("./base-client").RequestOptions): Promise<import("./namespaces/scopes").ScopeCatalog>;
    };
    /** Theme management — CRUD, registry import, and WCAG contrast reporting */
    readonly themes: {
        list: (options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").Theme[]>;
        get: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").Theme>;
        create: (attributes: import("./namespaces/themes").CreateThemeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").Theme>;
        update: (id: string, attributes: import("./namespaces/themes").UpdateThemeAttributes, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").Theme>;
        destroy: (id: string, options?: import("./base-client").RequestOptions) => Promise<true>;
        importFromUrl: (args: import("./namespaces/themes").ImportThemeFromUrlArgs, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").ImportThemeFromUrlResult>;
        getContrastReport: (id: string, options?: import("./base-client").RequestOptions) => Promise<import("./namespaces/themes").ThemeContrastReport>;
    };
    /** AI form generation (Slice 5) — async LLM-driven form authoring */
    readonly forms: {
        generations: {
            create(input: import("./namespaces/forms").CreateFormGenerationJobInput, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormGenerationJob>;
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormGenerationJob>;
            list(args: import("./namespaces/forms").ListFormGenerationsArgs, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormGenerationJob[]>;
            cancel(id: string, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormGenerationJob>;
        };
        versions: {
            classifyField(formVersionId: string, input: import("./namespaces/forms").ClassifyFieldInput, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormVersion>;
        };
        deployments: {
            list(options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormDeployment[]>;
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormDeployment>;
            create(attributes: import("./namespaces/forms").CreateFormDeploymentAttributes, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormDeployment>;
            update(id: string, attributes: import("./namespaces/forms").UpdateFormDeploymentAttributes, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormDeployment>;
            acceptUpdate(id: string, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").FormDeployment>;
            destroy(id: string, options?: import("./base-client").RequestOptions): Promise<boolean>;
        };
        workspaceConfigs: {
            list(options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").WorkspaceFormConfig[]>;
            get(id: string, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").WorkspaceFormConfig>;
            create(attributes: import("./namespaces/forms").CreateWorkspaceFormConfigAttributes, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").WorkspaceFormConfig>;
            update(id: string, attributes: import("./namespaces/forms").UpdateWorkspaceFormConfigAttributes, options?: import("./base-client").RequestOptions): Promise<import("./_internal/types.gen").WorkspaceFormConfig>;
            destroy(id: string, options?: import("./base-client").RequestOptions): Promise<boolean>;
        };
    };
    constructor(config?: BaseClientConfig);
}
//# sourceMappingURL=gpt-admin.d.ts.map