codika 3.0.0

package/dist/types/process-types.d.ts

@@ -0,0 +1,740 @@
+/**
+ * Process Types - Duplicated from codika_app_platform
+ * These types define the structure for process deployments
+ *
+ * UNIFIED FLAT STRUCTURE: All field properties are at the top level (no nested config)
+ */
+/**
+ * ProcessType values - use for setting values
+ * Example: processType: ProcessType.personal
+ *
+ * Controls how instances are created:
+ * - personal: Each user installs their own instance (default)
+ * - organizational: One shared instance per organization
+ */
+export declare const ProcessType: {
+    readonly personal: "personal";
+    readonly organizational: "organizational";
+};
+/**
+ * ProcessType type - use for type annotations
+ * Values: 'personal' | 'organizational'
+ */
+export type ProcessType = typeof ProcessType[keyof typeof ProcessType];
+/**
+ * Field types supported in form schemas
+ */
+export type FieldType = 'string' | 'text' | 'number' | 'boolean' | 'date' | 'select' | 'multiselect' | 'radio' | 'file' | 'array' | 'object' | 'objectArray';
+/**
+ * Base interface for all form fields
+ */
+export interface FormFieldBase {
+    key: string;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    placeholder?: string;
+    required?: boolean;
+}
+/**
+ * String field - single-line text input
+ */
+export interface FormStringField extends FormFieldBase {
+    type: 'string';
+    defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+    regexError?: string;
+}
+/**
+ * Text field - multi-line textarea
+ */
+export interface FormTextField extends FormFieldBase {
+    type: 'text';
+    defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+    regex?: string;
+    regexError?: string;
+}
+/**
+ * Number field - numeric input
+ */
+export interface FormNumberField extends FormFieldBase {
+    type: 'number';
+    defaultValue?: number;
+    numberType?: 'integer' | 'double';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/**
+ * Boolean field - checkbox or switch toggle
+ */
+export interface FormBooleanField extends FormFieldBase {
+    type: 'boolean';
+    defaultValue?: boolean;
+    enabledLabel?: string;
+    disabledLabel?: string;
+}
+/**
+ * Date field - date picker
+ */
+export interface FormDateField extends FormFieldBase {
+    type: 'date';
+    defaultValue?: string;
+    minDate?: string;
+    maxDate?: string;
+}
+/**
+ * Select field - dropdown single selection
+ */
+export interface FormSelectField extends FormFieldBase {
+    type: 'select';
+    defaultValue?: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/**
+ * MultiSelect field - multiple selection
+ */
+export interface FormMultiSelectField extends FormFieldBase {
+    type: 'multiselect';
+    defaultValue?: string[];
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    minSelections?: number;
+    maxSelections?: number;
+}
+/**
+ * Radio field - single selection with visible options
+ */
+export interface FormRadioField extends FormFieldBase {
+    type: 'radio';
+    defaultValue?: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/**
+ * File field - file upload
+ */
+export interface FormFileField extends FormFieldBase {
+    type: 'file';
+    maxSize?: number;
+    allowedMimeTypes?: string[];
+    showPreview?: boolean;
+    tags?: string[];
+}
+/**
+ * Base type for array item fields (primitive fields without key/label/required)
+ * These properties are managed by the array container itself
+ */
+type ArrayItemFieldBase = Omit<FormFieldBase, 'key' | 'label' | 'required'>;
+/**
+ * Union type for all primitive field types that can be used as array items
+ * (excludes array, objectArray, file, section, multiselect)
+ * Note: multiselect excluded because it produces nested arrays which Firestore cannot store
+ */
+export type FormArrayItemField = (ArrayItemFieldBase & Omit<FormStringField, keyof FormFieldBase> & {
+    type: 'string';
+}) | (ArrayItemFieldBase & Omit<FormTextField, keyof FormFieldBase> & {
+    type: 'text';
+}) | (ArrayItemFieldBase & Omit<FormNumberField, keyof FormFieldBase> & {
+    type: 'number';
+}) | (ArrayItemFieldBase & Omit<FormBooleanField, keyof FormFieldBase> & {
+    type: 'boolean';
+}) | (ArrayItemFieldBase & Omit<FormDateField, keyof FormFieldBase> & {
+    type: 'date';
+}) | (ArrayItemFieldBase & Omit<FormSelectField, keyof FormFieldBase> & {
+    type: 'select';
+}) | (ArrayItemFieldBase & Omit<FormRadioField, keyof FormFieldBase> & {
+    type: 'radio';
+});
+/**
+ * Array field - repeatable input of primitive values
+ *
+ * Uses itemField to define the field type and all its properties directly,
+ * giving access to ALL type-specific properties (e.g., rows for text fields).
+ */
+export interface FormArrayField extends FormFieldBase {
+    type: 'array';
+    defaultValue?: (string | number | boolean)[];
+    itemField: FormArrayItemField;
+    minItems?: number;
+    maxItems?: number;
+}
+/**
+ * Object field - single structured object with nested fields
+ */
+export interface FormObjectField extends FormFieldBase {
+    type: 'object';
+    schema: FormInputItem[];
+    defaultValue?: Record<string, unknown>;
+}
+/**
+ * ObjectArray field - array of structured objects
+ */
+export interface FormObjectArrayField extends FormFieldBase {
+    type: 'objectArray';
+    defaultValue?: Record<string, unknown>[];
+    itemSchema: FormInputItem[];
+    minItems?: number;
+    maxItems?: number;
+}
+/**
+ * Union type for all form field types
+ */
+export type FormField = FormStringField | FormTextField | FormNumberField | FormBooleanField | FormDateField | FormSelectField | FormMultiSelectField | FormRadioField | FormFileField | FormArrayField | FormObjectField | FormObjectArrayField;
+/**
+ * Section container for organizing fields
+ */
+export interface FormSection {
+    type: 'section';
+    title: string;
+    description?: string;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    inputSchema: FormInputItem[];
+}
+/**
+ * Item in form schema - either a field or a section
+ */
+export type FormInputItem = FormField | FormSection;
+/**
+ * Main form input schema - array of fields or sections
+ */
+export type FormInputSchema = FormInputItem[];
+/**
+ * Form Output Schema Types
+ */
+export type FormOutputItem = FormField | FormSection;
+export type FormOutputSchema = FormOutputItem[];
+export interface HttpTrigger {
+    triggerId: string;
+    type: 'http';
+    url: string;
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE';
+    title?: string | null;
+    description?: string;
+    inputSchema?: FormInputSchema;
+    authMethod?: 'none' | 'bearer' | 'basic';
+    authToken?: string;
+}
+export interface ScheduleTrigger {
+    triggerId: string;
+    type: 'schedule';
+    cronExpression: string;
+    timezone: string;
+    humanReadable: string;
+    manualTriggerUrl: string;
+    title?: string | null;
+    description?: string;
+}
+export interface ServiceEventTrigger {
+    triggerId: string;
+    type: 'service_event';
+    service: 'telegram' | 'email' | 'slack' | 'discord' | 'other';
+    eventType: string;
+    title?: string | null;
+    description?: string;
+}
+export type SubworkflowInputType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export interface SubworkflowInput {
+    name: string;
+    type: SubworkflowInputType;
+}
+export interface SubworkflowTrigger {
+    triggerId: string;
+    type: 'subworkflow';
+    title?: string | null;
+    description?: string;
+    inputSchema?: SubworkflowInput[];
+    calledBy?: string[];
+}
+export interface DataIngestionTrigger {
+    triggerId: string;
+    type: 'data_ingestion';
+    title?: string | null;
+    description?: string;
+    webhooks: {
+        embed: string;
+        delete: string;
+    };
+    cost?: number;
+}
+export type WorkflowTrigger = HttpTrigger | ScheduleTrigger | ServiceEventTrigger | SubworkflowTrigger | DataIngestionTrigger;
+/**
+ * Workflow Category
+ * Distinguishes user-facing workflows from internal data processing workflows
+ */
+export type WorkflowCategory = 'user_facing' | 'data_ingestion';
+/**
+ * Data Ingestion Endpoint Configuration
+ * Quick reference to the data ingestion workflow for fast lookup
+ */
+export interface DataIngestionEndpoint {
+    workflowTemplateId: string;
+    webhookUrl: string;
+    purpose: string;
+}
+/**
+ * Agent Configuration
+ * Defines an AI agent associated with a process deployment
+ */
+export interface AgentConfig {
+    id: string;
+    name: string;
+    systemPrompt: string;
+    title: string;
+    description: string;
+    welcomeMessage: string;
+}
+export interface KnowledgeBaseAccessConfig {
+    processDocTags: string[];
+    processInstanceDocTags: string[];
+}
+export interface WorkflowInfo {
+    workflowTemplateId: string;
+    workflowId: string;
+    workflowName: string;
+    triggers: WorkflowTrigger[];
+    markdownInfo?: string | null;
+    knowledgeBaseAccess: KnowledgeBaseAccessConfig;
+    integrationUids?: string[];
+    workflowCategory?: WorkflowCategory;
+    outputSchema?: FormOutputSchema;
+    n8nWorkflowJsonBase64?: string;
+    n8nWorkflowId?: string;
+    n8nWorkflowIsActive?: boolean;
+    n8nActivationError?: string;
+    cost?: number;
+    costEstimationForLLMTokens?: number;
+}
+export interface WorkflowConfigurationInput {
+    workflowTemplateId: string;
+    workflowId: string;
+    workflowName: string;
+    triggers: WorkflowTrigger[];
+    markdownInfo?: string;
+    knowledgeBaseAccess: KnowledgeBaseAccessConfig;
+    integrationUids?: string[];
+    workflowCategory?: WorkflowCategory;
+    outputSchema?: FormOutputSchema;
+    n8nWorkflowJsonBase64: string;
+    cost?: number;
+    costEstimationForLLMTokens?: number;
+}
+/**
+ * Field types for deployment parameters
+ * Excludes 'file' as it's not needed for deployment configuration
+ */
+export type DeploymentFieldType = Exclude<FieldType, 'file'>;
+/**
+ * Base interface for all deployment input fields
+ */
+export interface DeploymentFieldBase {
+    key: string;
+    type: DeploymentFieldType;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    placeholder?: string;
+    required?: boolean;
+}
+/**
+ * String field - single line text input
+ */
+export interface DeploymentStringField extends DeploymentFieldBase {
+    type: 'string';
+    defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+    regexError?: string;
+}
+/**
+ * Text field - multi-line textarea input
+ */
+export interface DeploymentTextField extends DeploymentFieldBase {
+    type: 'text';
+    defaultValue?: string;
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+    regex?: string;
+    regexError?: string;
+}
+/**
+ * Number field - numeric input
+ */
+export interface DeploymentNumberField extends DeploymentFieldBase {
+    type: 'number';
+    defaultValue?: number;
+    numberType?: 'integer' | 'double';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/**
+ * Boolean field - toggle/switch input
+ */
+export interface DeploymentBooleanField extends DeploymentFieldBase {
+    type: 'boolean';
+    defaultValue?: boolean;
+    enabledLabel?: string;
+    disabledLabel?: string;
+}
+/**
+ * Date field - date picker
+ */
+export interface DeploymentDateField extends DeploymentFieldBase {
+    type: 'date';
+    defaultValue?: string;
+    minDate?: string;
+    maxDate?: string;
+}
+/**
+ * Select field - dropdown single selection
+ */
+export interface DeploymentSelectField extends DeploymentFieldBase {
+    type: 'select';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: string;
+}
+/**
+ * MultiSelect field - multiple selection
+ */
+export interface DeploymentMultiSelectField extends DeploymentFieldBase {
+    type: 'multiselect';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: string[];
+    minSelections?: number;
+    maxSelections?: number;
+}
+/**
+ * Radio field - radio button group
+ */
+export interface DeploymentRadioField extends DeploymentFieldBase {
+    type: 'radio';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: string;
+}
+/**
+ * Base type for deployment array item fields (primitive fields without key/label/required)
+ * These properties are managed by the array container itself
+ */
+type DeploymentArrayItemFieldBase = Omit<DeploymentFieldBase, 'key' | 'label' | 'required'>;
+/**
+ * Union type for all primitive field types that can be used as deployment array items
+ * (excludes array, objectArray, object, section, file, multiselect)
+ * Note: multiselect excluded because it produces nested arrays which Firestore cannot store
+ */
+export type DeploymentArrayItemField = (DeploymentArrayItemFieldBase & Omit<DeploymentStringField, keyof DeploymentFieldBase> & {
+    type: 'string';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentTextField, keyof DeploymentFieldBase> & {
+    type: 'text';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentNumberField, keyof DeploymentFieldBase> & {
+    type: 'number';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentBooleanField, keyof DeploymentFieldBase> & {
+    type: 'boolean';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentDateField, keyof DeploymentFieldBase> & {
+    type: 'date';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentSelectField, keyof DeploymentFieldBase> & {
+    type: 'select';
+}) | (DeploymentArrayItemFieldBase & Omit<DeploymentRadioField, keyof DeploymentFieldBase> & {
+    type: 'radio';
+});
+/**
+ * Array field - repeatable input of primitive values
+ *
+ * Uses itemField to define the field type and all its properties directly,
+ * giving access to ALL type-specific properties (e.g., rows for text fields).
+ */
+export interface DeploymentArrayField extends DeploymentFieldBase {
+    type: 'array';
+    defaultValue?: (string | number | boolean)[];
+    /** Item field definition. Defaults to { type: 'string' } if not specified. */
+    itemField?: DeploymentArrayItemField;
+    minItems?: number;
+    maxItems?: number;
+}
+/**
+ * Object field - single structured object with nested fields
+ */
+export interface DeploymentObjectField extends DeploymentFieldBase {
+    type: 'object';
+    schema: DeploymentInputItem[];
+    defaultValue?: Record<string, unknown>;
+}
+/**
+ * ObjectArray field - array of objects with structured schema
+ */
+export interface DeploymentObjectArrayField extends DeploymentFieldBase {
+    type: 'objectArray';
+    itemSchema: DeploymentInputItem[];
+    defaultValue?: Record<string, unknown>[];
+    minItems?: number;
+    maxItems?: number;
+}
+/**
+ * Union type for all deployment input field types
+ */
+export type DeploymentInputField = DeploymentStringField | DeploymentTextField | DeploymentNumberField | DeploymentBooleanField | DeploymentDateField | DeploymentSelectField | DeploymentMultiSelectField | DeploymentRadioField | DeploymentArrayField | DeploymentObjectField | DeploymentObjectArrayField;
+/**
+ * Section for grouping deployment fields
+ */
+export interface DeploymentSection {
+    type: 'section';
+    title: string;
+    description?: string;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    inputSchema: DeploymentInputItem[];
+}
+/**
+ * Item in deployment input schema - either a field or a section
+ */
+export type DeploymentInputItem = DeploymentInputField | DeploymentSection;
+/**
+ * Schema for deployment input fields
+ */
+export type DeploymentInputSchema = DeploymentInputItem[];
+/**
+ * Type for deployment parameter values
+ */
+export type DeploymentParameterValue = string | number | boolean | string[] | (string | number | boolean)[] | Record<string, unknown> | Record<string, unknown>[];
+/**
+ * Record of deployment parameter values keyed by field key
+ */
+export type DeploymentParameterValues = Record<string, DeploymentParameterValue>;
+/**
+ * Field schema for a custom integration's secret or metadata field.
+ */
+export interface CustomIntegrationFieldSchema {
+    /** Field key, UPPER_SNAKE_CASE (e.g., 'API_KEY', 'BASE_URL') */
+    key: string;
+    /** Human-readable label */
+    label: string;
+    /** Field input type */
+    type: 'password' | 'string' | 'url' | 'number';
+    /** Help text for the field */
+    description?: string;
+    /** Placeholder text for the input */
+    placeholder?: string;
+    /** Whether the field is required (default: true for secrets, false for metadata) */
+    required?: boolean;
+}
+/**
+ * Schema for a custom integration defined by a use case.
+ * Allows use cases to declare arbitrary integration requirements
+ * without needing hardcoded handler files.
+ *
+ * Custom integration IDs MUST start with 'cstm_' to prevent collisions
+ * with built-in integration IDs.
+ */
+export interface CustomIntegrationSchema {
+    /** Unique ID, snake_case. Must start with 'cstm_' (e.g., 'cstm_acme_crm') */
+    id: string;
+    /** Display name shown in dashboard (e.g., 'Acme CRM') */
+    name: string;
+    /** Help text for users */
+    description?: string;
+    /** Where this integration is stored */
+    contextType: 'organization' | 'member' | 'process_instance';
+    /**
+     * n8n credential type to create. Maps to n8n's generic credential types:
+     * - 'httpHeaderAuth': API key in HTTP header (covers Bearer, X-API-Key, etc.)
+     * - 'httpBasicAuth': Username + password (HTTP Basic)
+     * - 'httpQueryAuth': API key as query parameter
+     * - 'none': No n8n credential (integration data used differently)
+     */
+    n8nCredentialType: 'httpHeaderAuth' | 'httpBasicAuth' | 'httpQueryAuth' | 'none';
+    /**
+     * Maps secret/metadata field keys to n8n credential data field names.
+     * Example for httpHeaderAuth: { 'API_KEY': 'value', 'HEADER_NAME': 'name' }
+     * Required when n8nCredentialType !== 'none'.
+     */
+    n8nCredentialMapping?: Record<string, string>;
+    /** Secret fields (encrypted, stored securely) */
+    secretFields: CustomIntegrationFieldSchema[];
+    /** Non-secret metadata fields (optional, for display/config) */
+    metadataFields?: CustomIntegrationFieldSchema[];
+    /** Lucide icon name for dashboard display (e.g., 'Building2') */
+    icon?: string;
+    /** URL to a custom logo image. Takes precedence over icon when provided. */
+    logoUrl?: string;
+    /** Primary color (hex) for dashboard display (e.g., '#4F46E5') */
+    color?: string;
+}
+export interface ProcessDeploymentConfigurationInput {
+    title: string;
+    subtitle: string;
+    description: string;
+    workflows: WorkflowConfigurationInput[];
+    processDeploymentMarkdown: string;
+    releaseNotes?: string;
+    tags: string[];
+    integrationUids: string[];
+    dataIngestionEndpoint?: DataIngestionEndpoint;
+    icon?: string;
+    deploymentInputSchema?: DeploymentInputSchema;
+    defaultDeploymentParameters?: DeploymentParameterValues;
+    agent?: AgentConfig;
+    processType?: ProcessType;
+    /**
+     * Custom integration schemas defined by this use case.
+     * Allows declaring arbitrary integration requirements that the platform
+     * handles dynamically — rendering forms, creating n8n credentials,
+     * and resolving placeholders.
+     *
+     * Custom integration IDs MUST start with 'cstm_'.
+     * IDs are automatically merged into integrationUids during deployment.
+     */
+    customIntegrations?: CustomIntegrationSchema[];
+}
+export type VersionStrategy = 'major_bump' | 'minor_bump' | 'explicit';
+/**
+ * Metadata document for deployment
+ * Represents ANY file with its relative path for exact reconstruction
+ */
+export interface MetadataDocument {
+    /** Relative path from use case root (e.g., "config.ts", "workflows/main.json", ".codika-agent/prd/prd.md") */
+    relativePath: string;
+    /** MIME content type (e.g., "application/json", "text/markdown") */
+    contentType: string;
+    /** Base64-encoded file content */
+    contentBase64: string;
+    /** Optional description of the document */
+    description?: string;
+}
+/**
+ * Result of uploading a metadata document
+ */
+export interface MetadataDocumentUploadResult {
+    /** Relative path for reconstruction */
+    relativePath: string;
+    /** Storage path in Firebase Storage */
+    storagePath: string;
+    /** Whether the upload was successful */
+    success: boolean;
+    /** Error message if upload failed */
+    error?: string;
+}
+/**
+ * A skill document describing how to interact with a specific workflow.
+ * Follows the Claude Agent Skills format: directory with SKILL.md + frontmatter.
+ * See: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
+ */
+export interface SkillDocument {
+    /** Must match a workflowTemplateId from the workflows array */
+    workflowTemplateId: string;
+    /** Skill name — max 64 chars, lowercase letters/numbers/hyphens only (Claude spec) */
+    name: string;
+    /** Short description, third person — max 1024 chars (Claude spec) */
+    description: string;
+    /** Full SKILL.md content including frontmatter */
+    contentMarkdown: string;
+    /** Relative path from use case root (e.g., "skills/main-workflow/SKILL.md") */
+    relativePath: string;
+}
+export interface DeployProcessUseCaseRequest {
+    projectId: string;
+    versionStrategy?: VersionStrategy;
+    explicitVersion?: string;
+    configuration: ProcessDeploymentConfigurationInput;
+    /** Optional metadata documents to store alongside the deployment */
+    metadataDocuments?: MetadataDocument[];
+    /** Skill documents describing how to interact with workflows */
+    skills?: SkillDocument[];
+}
+export interface DeployedWorkflowInfo {
+    workflowTemplateId: string;
+    n8nWorkflowId: string;
+    status: 'active' | 'inactive' | 'failed';
+}
+export interface DeployProcessUseCaseSuccessData {
+    templateId: string;
+    version: string;
+    isNewProcess: boolean;
+    processId: string;
+    processInstanceId?: string;
+    deploymentInstanceId: string;
+    workflowsDeployed: DeployedWorkflowInfo[];
+    deploymentStatus: 'deployed' | 'failed' | 'pending';
+    error?: string;
+    /** Results of metadata document uploads, if any were provided */
+    metadataDocumentsStored?: MetadataDocumentUploadResult[];
+}
+export interface DeployProcessUseCaseSuccessResponse {
+    success: true;
+    data: DeployProcessUseCaseSuccessData;
+    requestId: string;
+}
+export type DeployProcessUseCaseErrorCode = 'INVALID_REQUEST' | 'INVALID_PROJECT_ID' | 'INVALID_CONFIGURATION' | 'INVALID_WORKFLOW_JSON' | 'INVALID_VERSION' | 'UNAUTHORIZED' | 'PROJECT_NOT_FOUND' | 'ORGANIZATION_NOT_FOUND' | 'USER_NOT_FOUND' | 'DEPLOYMENT_IN_PROGRESS' | 'N8N_DEPLOYMENT_FAILED' | 'INTERNAL_ERROR';
+export interface DeployProcessUseCaseErrorDetails {
+    field?: string;
+    reason?: string;
+    index?: number;
+}
+export interface DeployProcessUseCaseErrorResponse {
+    success: false;
+    error: {
+        code: DeployProcessUseCaseErrorCode;
+        message: string;
+        details?: DeployProcessUseCaseErrorDetails;
+    };
+    requestId: string;
+}
+export type DeployProcessUseCaseResponse = DeployProcessUseCaseSuccessResponse | DeployProcessUseCaseErrorResponse;
+/**
+ * Process Data Ingestion Configuration Input
+ */
+export interface ProcessDataIngestionConfigInput {
+    workflowTemplateId: string;
+    workflowName: string;
+    n8nWorkflowJsonBase64: string;
+    webhooks: {
+        embed: string;
+        delete: string;
+    };
+    purpose: string;
+    markdownInfo?: string;
+    cost?: number;
+}
+export type DataIngestionVersionStrategy = 'major_bump' | 'minor_bump' | 'explicit';
+export interface DeployDataIngestionRequest {
+    processId: string;
+    versionStrategy?: DataIngestionVersionStrategy;
+    explicitVersion?: string;
+    config: ProcessDataIngestionConfigInput;
+}
+export interface DeployDataIngestionResponse {
+    success: boolean;
+    dataIngestionId: string;
+    version: string;
+    status: 'pending' | 'active' | 'failed' | 'inactive' | 'superseded';
+    webhookUrls?: {
+        embed: string;
+        delete: string;
+    };
+    error?: string;
+}
+export {};
+//# sourceMappingURL=process-types.d.ts.map