wiil-core-js 0.0.82

package/dist/core/type-definitions/dynamic-fields/field-definition.schema.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod";
+/**
+ * Schema for select/multiselect field options
+ */
+export declare const FieldOptionSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+    displayOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type FieldOption = z.infer<typeof FieldOptionSchema>;
+/**
+ * Validation rules schema for dynamic fields
+ */
+export declare const FieldValidationRulesSchema: z.ZodObject<{
+    required: z.ZodOptional<z.ZodBoolean>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+    patternMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FieldValidationRules = z.infer<typeof FieldValidationRulesSchema>;
+/**
+ * UI hints schema for field rendering
+ */
+export declare const FieldUIHintsSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    helpText: z.ZodOptional<z.ZodString>;
+    displayOrder: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        half: "half";
+        third: "third";
+    }>>;
+}, z.core.$strip>;
+export type FieldUIHints = z.infer<typeof FieldUIHintsSchema>;
+/**
+ * Condition operators for conditional field visibility
+ */
+export declare const FieldConditionOperators: readonly ["equals", "notEquals", "contains", "isEmpty", "isNotEmpty", "greaterThan", "lessThan"];
+/**
+ * Schema for conditional field visibility
+ * Show field X only if field Y meets a condition
+ */
+export declare const FieldConditionSchema: z.ZodObject<{
+    dependsOn: z.ZodString;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        contains: "contains";
+        isEmpty: "isEmpty";
+        isNotEmpty: "isNotEmpty";
+        greaterThan: "greaterThan";
+        lessThan: "lessThan";
+    }>;
+    value: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type FieldCondition = z.infer<typeof FieldConditionSchema>;
+/**
+ * Schema for field grouping/sections
+ * Organize fields into logical groups (e.g., "Contact Info", "Preferences")
+ */
+export declare const FieldGroupSchema: z.ZodObject<{
+    groupKey: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    displayOrder: z.ZodOptional<z.ZodNumber>;
+    collapsible: z.ZodOptional<z.ZodBoolean>;
+    defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FieldGroup = z.infer<typeof FieldGroupSchema>;
+/**
+ * Core field definition schema
+ * Defines a single dynamic field with its type, validation, and UI configuration
+ */
+export declare const FieldDefinitionSchema: z.ZodObject<{
+    fieldKey: z.ZodString;
+    fieldType: z.ZodEnum<{
+        text: import("./field-types").DynamicFieldType.TEXT;
+        textarea: import("./field-types").DynamicFieldType.TEXTAREA;
+        number: import("./field-types").DynamicFieldType.NUMBER;
+        boolean: import("./field-types").DynamicFieldType.BOOLEAN;
+        date: import("./field-types").DynamicFieldType.DATE;
+        time: import("./field-types").DynamicFieldType.TIME;
+        datetime: import("./field-types").DynamicFieldType.DATETIME;
+        email: import("./field-types").DynamicFieldType.EMAIL;
+        phone: import("./field-types").DynamicFieldType.PHONE;
+        select: import("./field-types").DynamicFieldType.SELECT;
+        multiselect: import("./field-types").DynamicFieldType.MULTISELECT;
+    }>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    validation: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        patternMessage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    uiHints: z.ZodOptional<z.ZodObject<{
+        placeholder: z.ZodOptional<z.ZodString>;
+        helpText: z.ZodOptional<z.ZodString>;
+        displayOrder: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            half: "half";
+            third: "third";
+        }>>;
+    }, z.core.$strip>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+        displayOrder: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    condition: z.ZodOptional<z.ZodObject<{
+        dependsOn: z.ZodString;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            notEquals: "notEquals";
+            contains: "contains";
+            isEmpty: "isEmpty";
+            isNotEmpty: "isNotEmpty";
+            greaterThan: "greaterThan";
+            lessThan: "lessThan";
+        }>;
+        value: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>>;
+    groupKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FieldDefinition = z.infer<typeof FieldDefinitionSchema>;
+/**
+ * Field override schema for service-level customization
+ * Allows overriding specific properties of inherited fields
+ */
+export declare const FieldOverrideSchema: z.ZodObject<{
+    fieldKey: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    validation: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        minLength: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        maxLength: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        min: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        max: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        pattern: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        patternMessage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    uiHints: z.ZodOptional<z.ZodObject<{
+        placeholder: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        helpText: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        displayOrder: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        width: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            half: "half";
+            third: "third";
+        }>>>;
+    }, z.core.$strip>>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FieldOverride = z.infer<typeof FieldOverrideSchema>;

package/dist/core/type-definitions/dynamic-fields/field-definition.schema.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldOverrideSchema = exports.FieldDefinitionSchema = exports.FieldGroupSchema = exports.FieldConditionSchema = exports.FieldConditionOperators = exports.FieldUIHintsSchema = exports.FieldValidationRulesSchema = exports.FieldOptionSchema = void 0;
+const zod_1 = require("zod");
+const field_types_1 = require("./field-types");
+/**
+ * Schema for select/multiselect field options
+ */
+exports.FieldOptionSchema = zod_1.z.object({
+    value: zod_1.z.string(),
+    label: zod_1.z.string(),
+    displayOrder: zod_1.z.number().int().optional(),
+});
+/**
+ * Validation rules schema for dynamic fields
+ */
+exports.FieldValidationRulesSchema = zod_1.z.object({
+    required: zod_1.z.boolean().optional(),
+    minLength: zod_1.z.number().int().positive().optional(),
+    maxLength: zod_1.z.number().int().positive().optional(),
+    min: zod_1.z.number().optional(),
+    max: zod_1.z.number().optional(),
+    pattern: zod_1.z.string().optional(),
+    patternMessage: zod_1.z.string().optional(),
+});
+/**
+ * UI hints schema for field rendering
+ */
+exports.FieldUIHintsSchema = zod_1.z.object({
+    placeholder: zod_1.z.string().optional(),
+    helpText: zod_1.z.string().optional(),
+    displayOrder: zod_1.z.number().int().optional(),
+    width: zod_1.z.enum(["full", "half", "third"]).optional(),
+});
+/**
+ * Condition operators for conditional field visibility
+ */
+exports.FieldConditionOperators = [
+    "equals",
+    "notEquals",
+    "contains",
+    "isEmpty",
+    "isNotEmpty",
+    "greaterThan",
+    "lessThan",
+];
+/**
+ * Schema for conditional field visibility
+ * Show field X only if field Y meets a condition
+ */
+exports.FieldConditionSchema = zod_1.z.object({
+    dependsOn: zod_1.z.string(),
+    operator: zod_1.z.enum(exports.FieldConditionOperators),
+    value: zod_1.z.any().optional(),
+});
+/**
+ * Schema for field grouping/sections
+ * Organize fields into logical groups (e.g., "Contact Info", "Preferences")
+ */
+exports.FieldGroupSchema = zod_1.z.object({
+    groupKey: zod_1.z.string(),
+    label: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    displayOrder: zod_1.z.number().int().optional(),
+    collapsible: zod_1.z.boolean().optional(),
+    defaultCollapsed: zod_1.z.boolean().optional(),
+});
+/**
+ * Core field definition schema
+ * Defines a single dynamic field with its type, validation, and UI configuration
+ */
+exports.FieldDefinitionSchema = zod_1.z.object({
+    fieldKey: zod_1.z.string()
+        .regex(/^[a-z][a-z0-9_]*$/, "Field key must be lowercase alphanumeric with underscores, starting with a letter"),
+    fieldType: zod_1.z.enum(field_types_1.DynamicFieldTypes),
+    label: zod_1.z.string().min(1),
+    description: zod_1.z.string().optional(),
+    validation: exports.FieldValidationRulesSchema.optional(),
+    uiHints: exports.FieldUIHintsSchema.optional(),
+    options: zod_1.z.array(exports.FieldOptionSchema).optional(),
+    defaultValue: zod_1.z.any().optional(),
+    isActive: zod_1.z.boolean().optional(),
+    condition: exports.FieldConditionSchema.optional(),
+    groupKey: zod_1.z.string().optional(),
+});
+/**
+ * Field override schema for service-level customization
+ * Allows overriding specific properties of inherited fields
+ */
+exports.FieldOverrideSchema = zod_1.z.object({
+    fieldKey: zod_1.z.string(),
+    label: zod_1.z.string().optional(),
+    validation: exports.FieldValidationRulesSchema.partial().optional(),
+    uiHints: exports.FieldUIHintsSchema.partial().optional(),
+    defaultValue: zod_1.z.any().optional(),
+    isActive: zod_1.z.boolean().optional(),
+});

package/dist/core/type-definitions/dynamic-fields/field-types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Dynamic Field Types
+ *
+ * Defines the supported field types for dynamic form field definitions.
+ * Used across appointment and other configurable form schemas.
+ */
+export declare enum DynamicFieldType {
+    /** Single-line text input */
+    TEXT = "text",
+    /** Multi-line text input */
+    TEXTAREA = "textarea",
+    /** Numeric input */
+    NUMBER = "number",
+    /** Boolean checkbox/toggle */
+    BOOLEAN = "boolean",
+    /** Date picker (date only) */
+    DATE = "date",
+    /** Time picker (time only) */
+    TIME = "time",
+    /** DateTime picker (date and time) */
+    DATETIME = "datetime",
+    /** Email input with validation */
+    EMAIL = "email",
+    /** Phone number input */
+    PHONE = "phone",
+    /** Single selection dropdown */
+    SELECT = "select",
+    /** Multiple selection input */
+    MULTISELECT = "multiselect"
+}
+/** Array of all dynamic field types for Zod enum usage */
+export declare const DynamicFieldTypes: readonly [DynamicFieldType.TEXT, DynamicFieldType.TEXTAREA, DynamicFieldType.NUMBER, DynamicFieldType.BOOLEAN, DynamicFieldType.DATE, DynamicFieldType.TIME, DynamicFieldType.DATETIME, DynamicFieldType.EMAIL, DynamicFieldType.PHONE, DynamicFieldType.SELECT, DynamicFieldType.MULTISELECT];
+/**
+ * Agent tool call parameter type definition
+ * Maps field types to JSON schema types for LLM tool calls
+ */
+export interface AgentToolParamType {
+    type: 'string' | 'number' | 'boolean' | 'array';
+    format?: string;
+    items?: {
+        type: string;
+    };
+    description: string;
+}
+/**
+ * Maps DynamicFieldType to agent tool call parameter types
+ * Used to generate tool call schemas for LLM agents
+ */
+export declare const DynamicFieldTypeToAgentToolParam: Record<DynamicFieldType, AgentToolParamType>;

package/dist/core/type-definitions/dynamic-fields/field-types.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Dynamic Field Types
+ *
+ * Defines the supported field types for dynamic form field definitions.
+ * Used across appointment and other configurable form schemas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicFieldTypeToAgentToolParam = exports.DynamicFieldTypes = exports.DynamicFieldType = void 0;
+var DynamicFieldType;
+(function (DynamicFieldType) {
+    /** Single-line text input */
+    DynamicFieldType["TEXT"] = "text";
+    /** Multi-line text input */
+    DynamicFieldType["TEXTAREA"] = "textarea";
+    /** Numeric input */
+    DynamicFieldType["NUMBER"] = "number";
+    /** Boolean checkbox/toggle */
+    DynamicFieldType["BOOLEAN"] = "boolean";
+    /** Date picker (date only) */
+    DynamicFieldType["DATE"] = "date";
+    /** Time picker (time only) */
+    DynamicFieldType["TIME"] = "time";
+    /** DateTime picker (date and time) */
+    DynamicFieldType["DATETIME"] = "datetime";
+    /** Email input with validation */
+    DynamicFieldType["EMAIL"] = "email";
+    /** Phone number input */
+    DynamicFieldType["PHONE"] = "phone";
+    /** Single selection dropdown */
+    DynamicFieldType["SELECT"] = "select";
+    /** Multiple selection input */
+    DynamicFieldType["MULTISELECT"] = "multiselect";
+})(DynamicFieldType || (exports.DynamicFieldType = DynamicFieldType = {}));
+/** Array of all dynamic field types for Zod enum usage */
+exports.DynamicFieldTypes = [
+    DynamicFieldType.TEXT,
+    DynamicFieldType.TEXTAREA,
+    DynamicFieldType.NUMBER,
+    DynamicFieldType.BOOLEAN,
+    DynamicFieldType.DATE,
+    DynamicFieldType.TIME,
+    DynamicFieldType.DATETIME,
+    DynamicFieldType.EMAIL,
+    DynamicFieldType.PHONE,
+    DynamicFieldType.SELECT,
+    DynamicFieldType.MULTISELECT,
+];
+/**
+ * Maps DynamicFieldType to agent tool call parameter types
+ * Used to generate tool call schemas for LLM agents
+ */
+exports.DynamicFieldTypeToAgentToolParam = {
+    [DynamicFieldType.TEXT]: {
+        type: 'string',
+        description: 'Single-line text value',
+    },
+    [DynamicFieldType.TEXTAREA]: {
+        type: 'string',
+        description: 'Multi-line text value',
+    },
+    [DynamicFieldType.NUMBER]: {
+        type: 'number',
+        description: 'Numeric value',
+    },
+    [DynamicFieldType.BOOLEAN]: {
+        type: 'boolean',
+        description: 'True or false value',
+    },
+    [DynamicFieldType.DATE]: {
+        type: 'string',
+        format: 'date',
+        description: 'Date in ISO 8601 format (YYYY-MM-DD)',
+    },
+    [DynamicFieldType.TIME]: {
+        type: 'string',
+        format: 'time',
+        description: 'Time in 24-hour format (HH:MM)',
+    },
+    [DynamicFieldType.DATETIME]: {
+        type: 'string',
+        format: 'date-time',
+        description: 'Date and time in ISO 8601 format (YYYY-MM-DDTHH:MM:SS)',
+    },
+    [DynamicFieldType.EMAIL]: {
+        type: 'string',
+        format: 'email',
+        description: 'Valid email address',
+    },
+    [DynamicFieldType.PHONE]: {
+        type: 'string',
+        format: 'phone',
+        description: 'Phone number with country code',
+    },
+    [DynamicFieldType.SELECT]: {
+        type: 'string',
+        description: 'Single selection from available options',
+    },
+    [DynamicFieldType.MULTISELECT]: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Multiple selections from available options',
+    },
+};

package/dist/core/type-definitions/dynamic-fields/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Dynamic Fields Module
+ *
+ * Provides reusable schemas for defining dynamic form fields at runtime.
+ * Supports field type definitions, validation rules, and UI hints for
+ * flexible form configuration across various business entities.
+ */
+export * from './field-types';
+export * from './field-definition.schema';

package/dist/core/type-definitions/dynamic-fields/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Dynamic Fields Module
+ *
+ * Provides reusable schemas for defining dynamic form fields at runtime.
+ * Supports field type definitions, validation rules, and UI hints for
+ * flexible form configuration across various business entities.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./field-types"), exports);
+__exportStar(require("./field-definition.schema"), exports);

package/dist/core/type-definitions/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Central export point for all type definitions.
+ * @module type-definitions
+ */
+export * from './account-definitions';
+export * from './service-config.definitions';
+export * from './business-definitions';
+export * from './conversation.type.definition';
+export * from './knowledge-definitions';
+export * from './display-order';

package/dist/core/type-definitions/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @fileoverview Central export point for all type definitions.
+ * @module type-definitions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./account-definitions"), exports);
+__exportStar(require("./service-config.definitions"), exports);
+__exportStar(require("./business-definitions"), exports);
+__exportStar(require("./conversation.type.definition"), exports);
+__exportStar(require("./knowledge-definitions"), exports);
+__exportStar(require("./display-order"), exports);

package/dist/core/type-definitions/knowledge-definitions.d.ts

@@ -0,0 +1,30 @@
+export declare enum KnowledgeBaseProcessingStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+export declare enum KnowledgeTypes {
+    DOCUMENT = "document",
+    URL = "url",
+    BUSINESS_WEBSITE = "business_website",
+    CORPUS = "corpus",
+    BATCH_DOCUMENT = "batch_document"
+}
+export declare enum StorageTier {
+    FIRESTORE = "firestore",
+    CLOUD_STORAGE_STANDARD = "cloud_storage_standard",
+    CLOUD_STORAGE_COLDLINE = "cloud_storage_coldline"
+}
+export declare enum SupportedDocumentTypes {
+    PDF = "application/pdf",
+    DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    TXT = "text/plain",
+    MD = "text/markdown",
+    RTF = "application/rtf",
+    HTML = "text/html",
+    WORD = "application/msword",
+    CSV = "text/csv",
+    XLS = "application/vnd.ms-excel",
+    XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+}

package/dist/core/type-definitions/knowledge-definitions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedDocumentTypes = exports.StorageTier = exports.KnowledgeTypes = exports.KnowledgeBaseProcessingStatus = void 0;
+var KnowledgeBaseProcessingStatus;
+(function (KnowledgeBaseProcessingStatus) {
+    KnowledgeBaseProcessingStatus["PENDING"] = "pending";
+    KnowledgeBaseProcessingStatus["PROCESSING"] = "processing";
+    KnowledgeBaseProcessingStatus["COMPLETED"] = "completed";
+    KnowledgeBaseProcessingStatus["FAILED"] = "failed";
+})(KnowledgeBaseProcessingStatus || (exports.KnowledgeBaseProcessingStatus = KnowledgeBaseProcessingStatus = {}));
+var KnowledgeTypes;
+(function (KnowledgeTypes) {
+    KnowledgeTypes["DOCUMENT"] = "document";
+    KnowledgeTypes["URL"] = "url";
+    KnowledgeTypes["BUSINESS_WEBSITE"] = "business_website";
+    KnowledgeTypes["CORPUS"] = "corpus";
+    KnowledgeTypes["BATCH_DOCUMENT"] = "batch_document";
+})(KnowledgeTypes || (exports.KnowledgeTypes = KnowledgeTypes = {}));
+var StorageTier;
+(function (StorageTier) {
+    StorageTier["FIRESTORE"] = "firestore";
+    StorageTier["CLOUD_STORAGE_STANDARD"] = "cloud_storage_standard";
+    StorageTier["CLOUD_STORAGE_COLDLINE"] = "cloud_storage_coldline";
+})(StorageTier || (exports.StorageTier = StorageTier = {}));
+var SupportedDocumentTypes;
+(function (SupportedDocumentTypes) {
+    SupportedDocumentTypes["PDF"] = "application/pdf";
+    SupportedDocumentTypes["DOCX"] = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    SupportedDocumentTypes["TXT"] = "text/plain";
+    SupportedDocumentTypes["MD"] = "text/markdown";
+    SupportedDocumentTypes["RTF"] = "application/rtf";
+    SupportedDocumentTypes["HTML"] = "text/html";
+    SupportedDocumentTypes["WORD"] = "application/msword";
+    SupportedDocumentTypes["CSV"] = "text/csv";
+    SupportedDocumentTypes["XLS"] = "application/vnd.ms-excel";
+    SupportedDocumentTypes["XLSX"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+})(SupportedDocumentTypes || (exports.SupportedDocumentTypes = SupportedDocumentTypes = {}));

package/dist/core/type-definitions/service-config.definitions.d.ts

@@ -0,0 +1,112 @@
+import { BusinessSupportServices } from "./account-definitions";
+export declare enum DeploymentType {
+    CALLS = "calls",
+    SMS = "sms",
+    WEB = "web",
+    MOBILE = "mobile-app",
+    WHATSAPP = "whatsapp",
+    EMAIL = "email"
+}
+export declare enum DeploymentStatus {
+    PENDING = "pending",
+    ACTIVE = "active",
+    PAUSED = "paused",
+    ARCHIVED = "archived"
+}
+export declare enum ProviderType {
+    TWILIO = "twilio",
+    SIGNALWIRE = "signal-wire",
+    TELNYX = "telnyx",
+    MESSAGEBIRD = "messagebird",
+    SNS = "sns"
+}
+export declare enum EmailProviderType {
+    GOOGLE = "google",
+    OUTLOOK = "outlook",
+    SENDGRID = "sendgrid",
+    SES = "ses",
+    MAILGUN = "mailgun",
+    POSTMARK = "postmark",
+    SMTP = "smtp"
+}
+export declare enum PhonePurchaseStatus {
+    PENDING = "pending",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+export declare enum PhoneStatus {
+    ACTIVE = "ACTIVE",// used in both SMS and Call channels
+    INACTIVE = "INACTIVE",// not used
+    SMS_ACTIVE = "SMS_ACTIVE",//used in SMS channel
+    CALL_ACTIVE = "CALL_ACTIVE"
+}
+export declare enum PhoneNumberType {
+    LOCAL = "local",
+    TOLL_FREE = "toll-free"
+}
+export declare enum MobilePlatform {
+    IOS = "ios",
+    ANDROID = "android"
+}
+export declare enum OttCommunicationType {
+    TEXT = "text",
+    VOICE = "voice",
+    UNIFIED = "unified"
+}
+export declare enum DeploymentProvisioningType {
+    DIRECT = "direct",
+    CHAINED = "chained"
+}
+export declare enum AssistantType {
+    PHONE = "phone",
+    WEB = "web",
+    EMAIL = "email",
+    GENERAL = "general"
+}
+export declare enum LLMType {
+    STS = "sts",
+    TTS = "tts",
+    STT = "stt",
+    TRANSCRIBE = "transcribe",
+    TEXT_PROCESSING = "text",
+    MULTI_MODE = "multi_mode"
+}
+export declare enum SupportedProprietor {
+    OPENAI = "OpenAI",
+    GOOGLE = "Google",
+    ANTHROPIC = "Anthropic",
+    GROQ = "Groq",
+    XAI = "xAI",
+    DEEPGRAM = "Deepgram",
+    ELEVENLABS = "ElevenLabs",
+    DEEPSEEK = "DeepSeek",
+    CARTESIA = "Cartesia"
+}
+export declare enum SupportedLLMKit {
+    OPEN_AI = "openai-kit",
+    GOOGLE = "google-kit",
+    ANTHROPIC = "anthropic-kit",
+    GROQ = "groq-kit",
+    XAI = "xai-kit",
+    DEEPGRAM = "deepgram-kit",
+    ELEVENLABS = "elevenlabs-kit",
+    DEEPSEEK = "deepseek-kit",
+    CARTESIA = "cartesia-kit"
+}
+export declare enum LLMRequestType {
+    TEXT = "text",
+    AUDIO = "audio",
+    IMAGE = "image",
+    VIDEO = "video",
+    MULTIMODAL = "multimodal"
+}
+export declare enum AgentRoleTemplateIdentifier {
+    CUSTOMER_SUPPORT_GENERAL = "customer-support-general",
+    TECHNICAL_SUPPORT_SPECIALIST = "technical-support-specialist",
+    SALES_REPRESENTATIVE = "sales-representative",
+    ONBOARDING_SPECIALIST = "onboarding-specialist",
+    BILLING_SUPPORT_SPECIALIST = "billing-support-specialist"
+}
+export declare const AgentCapabilities: typeof BusinessSupportServices;
+export type AgentCapabilities = BusinessSupportServices;