fireberry-api-client 1.0.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,871 @@
+import { Q as QueryBuilder } from './excludedFields-CGXgZN8Y.js';
+export { E as EXCLUDED_FIELDS_FOR_STAR_QUERY, F as FIELD_TYPE_IDS, a as FIELD_TYPE_MAPPINGS, O as OBJECT_ID_MAP, b as OBJECT_NAME_MAP, e as escapeQueryValue, s as sanitizeQuery } from './excludedFields-CGXgZN8Y.js';
+
+/**
+ * Configuration options for FireberryClient
+ */
+interface FireberryClientConfig {
+    /** Fireberry API key */
+    apiKey: string;
+    /** Base URL for API requests (default: https://api.fireberry.com) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Whether to retry on 429 rate limit errors (default: true) */
+    retryOn429?: boolean;
+    /** Maximum number of retries for 429 errors (default: 120) */
+    maxRetries?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
+    /** Enable in-memory metadata cache (default: false) */
+    cacheMetadata?: boolean;
+    /** Cache TTL in milliseconds (default: 300000 = 5 minutes) */
+    cacheTTL?: number;
+}
+/**
+ * Options for HTTP requests
+ */
+interface RequestOptions {
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** API endpoint path */
+    endpoint: string;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean>;
+    /** Request body */
+    body?: unknown;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Cache control interface
+ */
+interface CacheControl {
+    /** Clear entire cache */
+    clear(): void;
+    /** Clear fields cache for an object type */
+    clearFields(objectType: string): void;
+    /** Clear field values cache for a specific field */
+    clearFieldValues(objectType: string, fieldName: string): void;
+    /** Clear objects cache */
+    clearObjects(): void;
+}
+
+/**
+ * Options for query operations
+ */
+interface QueryOptions {
+    /** Object type ID */
+    objectType: string;
+    /** Fields to return (array or comma-separated string, '*' for all) */
+    fields?: string | string[];
+    /** Query filter string */
+    query?: string;
+    /** Field to sort by (default: modifiedon) */
+    sortBy?: string;
+    /** Sort direction (default: desc) */
+    sortType?: 'asc' | 'desc';
+    /** Maximum number of records to return */
+    limit?: number;
+    /** Whether to return label values alongside IDs for dropdowns/lookups */
+    showRealValue?: boolean;
+    /** Page number (1-indexed) */
+    page?: number;
+    /** Page size (default: 500, max: 500) */
+    pageSize?: number;
+    /** Automatically fetch all pages (default: true) */
+    autoPage?: boolean;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Query result
+ */
+interface QueryResult<T = Record<string, unknown>> {
+    /** Array of records */
+    records: T[];
+    /** Total number of records returned */
+    total: number;
+    /** Whether the query was successful */
+    success: boolean;
+}
+/**
+ * Query condition item for query builder
+ */
+interface QueryConditionItem {
+    itemType: 'condition';
+    field: string;
+    operator: QueryOperator;
+    value?: string;
+    joinOperator?: 'and' | 'or';
+}
+/**
+ * Query separator item for grouping
+ */
+interface QuerySeparatorItem {
+    itemType: 'separator';
+    logicOperator: 'and' | 'or';
+}
+/**
+ * Query item type
+ */
+type QueryItem = QueryConditionItem | QuerySeparatorItem;
+/**
+ * Native Fireberry query operators
+ */
+type QueryOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'start-with' | 'not-start-with' | 'is-null' | 'is-not-null';
+
+/**
+ * Fireberry object/entity type
+ */
+interface FireberryObject {
+    /** Object type ID */
+    objectType: number;
+    /** Display name */
+    name: string;
+    /** System name (API name) */
+    systemName: string;
+}
+/**
+ * Fireberry field metadata
+ */
+interface FireberryField {
+    /** Field API name */
+    fieldName: string;
+    /** Field display label */
+    label: string;
+    /** System field type ID (UUID) */
+    systemFieldTypeId: string;
+    /** Human-readable field type */
+    fieldType?: string;
+    /** Whether field is required */
+    required?: boolean;
+    /** Default value if any */
+    defaultValue?: unknown;
+    /** Max length for text fields */
+    maxLength?: number;
+    /** Precision for number fields */
+    precision?: number;
+    /** Related object ID for lookup fields */
+    relatedObjectId?: string;
+}
+/**
+ * Dropdown/picklist value
+ */
+interface FieldValue {
+    /** Display name */
+    name: string;
+    /** Value (usually numeric ID) */
+    value: string;
+}
+/**
+ * Result of getObjects operation
+ */
+interface GetObjectsResult {
+    /** Array of objects */
+    objects: FireberryObject[];
+    /** Total count */
+    total: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Result of getFields operation
+ */
+interface GetFieldsResult {
+    /** Object type ID */
+    objectTypeId: string;
+    /** Array of fields */
+    fields: FireberryField[];
+    /** Total count */
+    total: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Result of getFieldValues operation
+ */
+interface GetFieldValuesResult {
+    /** Object type ID */
+    objectTypeId: string;
+    /** Field name */
+    fieldName: string;
+    /** Array of values */
+    values: FieldValue[];
+    /** Total count */
+    total: number;
+    /** Success flag */
+    success: boolean;
+}
+
+/**
+ * Metadata API for retrieving Fireberry schema information
+ */
+declare class MetadataAPI {
+    private readonly client;
+    constructor(client: FireberryClient);
+    /**
+     * Gets all available objects/entity types from Fireberry
+     *
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns List of all objects
+     *
+     * @example
+     * ```typescript
+     * const result = await client.metadata.getObjects();
+     * console.log(result.objects); // [{ objectType: 1, name: 'Account', ... }, ...]
+     * ```
+     */
+    getObjects(signal?: AbortSignal): Promise<GetObjectsResult>;
+    /**
+     * Gets all fields for a specific object type
+     *
+     * @param objectType - The object type ID (e.g., '1' for Account)
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns List of fields with metadata
+     *
+     * @example
+     * ```typescript
+     * const result = await client.metadata.getFields('1');
+     * console.log(result.fields); // [{ fieldName: 'accountid', label: 'Account ID', ... }, ...]
+     * ```
+     */
+    getFields(objectType: string | number, signal?: AbortSignal): Promise<GetFieldsResult>;
+    /**
+     * Gets all possible values for a dropdown field
+     *
+     * @param objectType - The object type ID
+     * @param fieldName - The field name
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns List of dropdown values
+     *
+     * @example
+     * ```typescript
+     * const result = await client.metadata.getFieldValues('1', 'statuscode');
+     * console.log(result.values); // [{ name: 'Active', value: '1' }, { name: 'Inactive', value: '2' }]
+     * ```
+     */
+    getFieldValues(objectType: string | number, fieldName: string, signal?: AbortSignal): Promise<GetFieldValuesResult>;
+}
+
+/**
+ * Generic record type
+ */
+type FireberryRecord = Record<string, unknown>;
+/**
+ * Options for create operation
+ */
+interface CreateOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Options for update operation
+ */
+interface UpdateOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Options for delete operation
+ */
+interface DeleteOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Options for upsert operation
+ */
+interface UpsertOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Result of upsert operation
+ */
+interface UpsertResult {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Type of operation performed */
+    operationType: 'create' | 'update';
+    /** Key fields used for matching */
+    upsertKeys: string[];
+    /** Values of key fields */
+    upsertKeyValues: Record<string, unknown>;
+    /** Previous record data (null if created) */
+    oldRecord: FireberryRecord | null;
+    /** New record data */
+    newRecord: FireberryRecord;
+}
+/**
+ * Options for batch create operation
+ */
+interface BatchCreateOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Options for batch update operation
+ */
+interface BatchUpdateOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Record for batch update (includes id)
+ */
+interface BatchUpdateRecord {
+    id: string;
+    record: FireberryRecord;
+}
+/**
+ * Options for batch delete operation
+ */
+interface BatchDeleteOptions {
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Result of batch operation
+ */
+interface BatchResult {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Response data from API */
+    data: unknown[];
+    /** Number of records processed */
+    count: number;
+}
+/**
+ * Result of batch delete operation
+ */
+interface BatchDeleteResult {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** IDs of deleted records */
+    ids: string[];
+    /** Number of records deleted */
+    count: number;
+}
+
+/**
+ * Records API for CRUD operations on Fireberry records
+ */
+declare class RecordsAPI {
+    private readonly client;
+    constructor(client: FireberryClient);
+    /**
+     * Creates a new record in Fireberry
+     *
+     * @param objectType - The object type ID (e.g., '1' for Account)
+     * @param data - Record data to create
+     * @param options - Optional settings
+     * @returns Created record data
+     *
+     * @example
+     * ```typescript
+     * const result = await client.records.create('1', {
+     *   accountname: 'New Account',
+     *   emailaddress1: 'contact@example.com',
+     * });
+     * ```
+     */
+    create(objectType: string | number, data: FireberryRecord, options?: CreateOptions): Promise<FireberryRecord>;
+    /**
+     * Updates an existing record in Fireberry
+     *
+     * @param objectType - The object type ID
+     * @param recordId - The record ID to update
+     * @param data - Record data to update
+     * @param options - Optional settings
+     * @returns Updated record data
+     *
+     * @example
+     * ```typescript
+     * const result = await client.records.update('1', 'abc123', {
+     *   accountname: 'Updated Account Name',
+     * });
+     * ```
+     */
+    update(objectType: string | number, recordId: string, data: FireberryRecord, options?: UpdateOptions): Promise<FireberryRecord>;
+    /**
+     * Deletes a record from Fireberry
+     *
+     * @param objectType - The object type ID
+     * @param recordId - The record ID to delete
+     * @param options - Optional settings
+     * @returns Success status
+     *
+     * @example
+     * ```typescript
+     * await client.records.delete('1', 'abc123');
+     * ```
+     */
+    delete(objectType: string | number, recordId: string, options?: DeleteOptions): Promise<{
+        success: boolean;
+        id: string;
+    }>;
+    /**
+     * Upserts a record (creates if not exists, updates if exists)
+     *
+     * @param objectType - The object type ID
+     * @param keyFields - Fields to use for matching existing records
+     * @param data - Record data to upsert
+     * @param options - Optional settings
+     * @returns Upsert result with operation type and record data
+     *
+     * @example
+     * ```typescript
+     * const result = await client.records.upsert('1', ['emailaddress1'], {
+     *   accountname: 'Acme Corp',
+     *   emailaddress1: 'contact@acme.com',
+     * });
+     * console.log(result.operationType); // 'create' or 'update'
+     * ```
+     */
+    upsert(objectType: string | number, keyFields: string[], data: FireberryRecord, options?: UpsertOptions): Promise<UpsertResult>;
+}
+
+/**
+ * Batch API for bulk operations on Fireberry records
+ * Automatically chunks large datasets into API-compatible batches of 20
+ */
+declare class BatchAPI {
+    private readonly client;
+    constructor(client: FireberryClient);
+    /**
+     * Creates multiple records in batch
+     * Automatically chunks into batches of 20 records
+     *
+     * @param objectType - The object type ID
+     * @param records - Array of records to create
+     * @param options - Optional settings
+     * @returns Batch result with all created records
+     *
+     * @example
+     * ```typescript
+     * const result = await client.batch.create('1', [
+     *   { accountname: 'Account 1' },
+     *   { accountname: 'Account 2' },
+     * ]);
+     * console.log(result.count); // 2
+     * ```
+     */
+    create(objectType: string | number, records: FireberryRecord[], options?: BatchCreateOptions): Promise<BatchResult>;
+    /**
+     * Updates multiple records in batch
+     * Automatically chunks into batches of 20 records
+     *
+     * @param objectType - The object type ID
+     * @param records - Array of records with ID and data to update
+     * @param options - Optional settings
+     * @returns Batch result with all updated records
+     *
+     * @example
+     * ```typescript
+     * const result = await client.batch.update('1', [
+     *   { id: 'abc123', record: { accountname: 'Updated 1' } },
+     *   { id: 'def456', record: { accountname: 'Updated 2' } },
+     * ]);
+     * ```
+     */
+    update(objectType: string | number, records: BatchUpdateRecord[], options?: BatchUpdateOptions): Promise<BatchResult>;
+    /**
+     * Deletes multiple records in batch
+     * Automatically chunks into batches of 20 records
+     *
+     * @param objectType - The object type ID
+     * @param recordIds - Array of record IDs to delete
+     * @param options - Optional settings
+     * @returns Batch delete result with deleted IDs
+     *
+     * @example
+     * ```typescript
+     * const result = await client.batch.delete('1', ['abc123', 'def456']);
+     * console.log(result.ids); // ['abc123', 'def456']
+     * ```
+     */
+    delete(objectType: string | number, recordIds: string[], options?: BatchDeleteOptions): Promise<BatchDeleteResult>;
+}
+
+/**
+ * Field types supported for creation
+ */
+type CreateFieldType = 'text' | 'textarea' | 'email' | 'url' | 'phone' | 'number' | 'date' | 'datetime' | 'html' | 'lookup' | 'picklist' | 'formula' | 'summary';
+/**
+ * Base options for creating a field
+ */
+interface CreateFieldOptionsBase {
+    /** Field type */
+    type: CreateFieldType;
+    /** Field API name (must be unique, should start with 'pcf') */
+    fieldName: string;
+    /** Display label */
+    label: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Track changes */
+    follow?: boolean;
+    /** Enable auto-complete */
+    autoComplete?: boolean;
+}
+/**
+ * Options for text/email/url fields
+ */
+interface CreateTextFieldOptions extends CreateFieldOptionsBase {
+    type: 'text' | 'email' | 'url';
+    /** Maximum length (1-200) */
+    maxLength?: number;
+}
+/**
+ * Options for number fields
+ */
+interface CreateNumberFieldOptions extends CreateFieldOptionsBase {
+    type: 'number';
+    /** Decimal precision (0-4) */
+    precision?: number;
+}
+/**
+ * Options for lookup fields
+ */
+interface CreateLookupFieldOptions extends CreateFieldOptionsBase {
+    type: 'lookup';
+    /** Related object type ID */
+    relatedObjectId: string;
+}
+/**
+ * Picklist value for field creation
+ */
+interface PicklistValue {
+    name: string;
+    value: string;
+}
+/**
+ * Options for picklist fields
+ */
+interface CreatePicklistFieldOptions extends CreateFieldOptionsBase {
+    type: 'picklist';
+    /** Picklist values */
+    values: PicklistValue[];
+}
+/**
+ * Summary types
+ */
+type SummaryType = 'avg' | 'count' | 'max' | 'min' | 'sum';
+/**
+ * Options for summary fields
+ */
+interface CreateSummaryFieldOptions extends CreateFieldOptionsBase {
+    type: 'summary';
+    /** Summary calculation type */
+    summaryType: SummaryType;
+    /** Related object to summarize */
+    relatedObjectId: string;
+    /** Field to summarize (required for sum, avg, min, max) */
+    summaryField?: string;
+}
+/**
+ * Formula result types
+ */
+type FormulaFieldType = 'text' | 'number' | 'date' | 'boolean';
+/**
+ * Options for formula fields
+ */
+interface CreateFormulaFieldOptions extends CreateFieldOptionsBase {
+    type: 'formula';
+    /** Formula expression */
+    formula: string;
+    /** Output field type */
+    formulaFieldType: FormulaFieldType;
+    /** Precision for numeric formulas */
+    formulaPrecision?: number;
+}
+/**
+ * Options for other simple fields
+ */
+interface CreateSimpleFieldOptions extends CreateFieldOptionsBase {
+    type: 'textarea' | 'phone' | 'date' | 'datetime' | 'html';
+}
+/**
+ * Union type for all field creation options
+ */
+type CreateFieldOptions = CreateTextFieldOptions | CreateNumberFieldOptions | CreateLookupFieldOptions | CreatePicklistFieldOptions | CreateSummaryFieldOptions | CreateFormulaFieldOptions | CreateSimpleFieldOptions;
+/**
+ * Result of field creation
+ */
+interface CreateFieldResult {
+    /** Object type ID */
+    objectTypeId: string;
+    /** Field type */
+    fieldType: CreateFieldType;
+    /** Created field data */
+    fieldData: Record<string, unknown>;
+    /** Success flag */
+    success: boolean;
+}
+
+/**
+ * Fields API for creating custom fields in Fireberry
+ */
+declare class FieldsAPI {
+    private readonly client;
+    constructor(client: FireberryClient);
+    /**
+     * Creates a new custom field in a Fireberry object
+     *
+     * @param objectType - The object type ID
+     * @param options - Field creation options
+     * @returns Created field result
+     *
+     * @example
+     * ```typescript
+     * // Create a text field
+     * const result = await client.fields.create('1', {
+     *   type: 'text',
+     *   fieldName: 'pcf_custom_field',
+     *   label: 'Custom Field',
+     *   maxLength: 100,
+     * });
+     *
+     * // Create a picklist field
+     * const result = await client.fields.create('1', {
+     *   type: 'picklist',
+     *   fieldName: 'pcf_status',
+     *   label: 'Status',
+     *   values: [
+     *     { name: 'Active', value: '1' },
+     *     { name: 'Inactive', value: '2' },
+     *   ],
+     * });
+     *
+     * // Create a lookup field
+     * const result = await client.fields.create('2', {
+     *   type: 'lookup',
+     *   fieldName: 'pcf_related_account',
+     *   label: 'Related Account',
+     *   relatedObjectId: '1',
+     * });
+     * ```
+     */
+    create(objectType: string | number, options: CreateFieldOptions): Promise<CreateFieldResult>;
+}
+
+/**
+ * Options for file upload
+ */
+interface FileUploadOptions {
+    /** File content as Buffer */
+    buffer: Buffer;
+    /** File name */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+}
+/**
+ * Result of file upload
+ */
+interface FileUploadResult {
+    /** Success flag */
+    success: boolean;
+    /** Object type */
+    objectType: string;
+    /** Record ID */
+    recordId: string;
+    /** Uploaded file name */
+    fileName: string;
+    /** File MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    fileSize: number;
+    /** API response */
+    response: unknown;
+}
+/**
+ * Files API for file operations in Fireberry
+ */
+declare class FilesAPI {
+    private readonly client;
+    constructor(client: FireberryClient);
+    /**
+     * Uploads a file attachment to a Fireberry record
+     *
+     * @param objectType - The object type ID
+     * @param recordId - The record ID to attach the file to
+     * @param options - File upload options
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns Upload result
+     *
+     * @example
+     * ```typescript
+     * import { readFileSync } from 'fs';
+     *
+     * const fileBuffer = readFileSync('document.pdf');
+     * const result = await client.files.upload('1', 'abc123', {
+     *   buffer: fileBuffer,
+     *   filename: 'document.pdf',
+     *   mimeType: 'application/pdf',
+     * });
+     * ```
+     */
+    upload(objectType: string | number, recordId: string, options: FileUploadOptions, signal?: AbortSignal): Promise<FileUploadResult>;
+}
+
+/**
+ * FireberryClient - Main client for interacting with the Fireberry CRM API
+ *
+ * @example
+ * ```typescript
+ * const client = new FireberryClient({
+ *   apiKey: 'your-api-key',
+ *   retryOn429: true,
+ *   maxRetries: 120,
+ * });
+ *
+ * // Query records
+ * const result = await client.query({
+ *   objectType: '1',
+ *   fields: ['accountid', 'name'],
+ *   query: '(statuscode = 1)',
+ * });
+ *
+ * // Use query builder
+ * const result = await client.queryBuilder()
+ *   .objectType('1')
+ *   .select('accountid', 'name')
+ *   .where('statuscode').equals('1')
+ *   .execute();
+ * ```
+ */
+declare class FireberryClient {
+    private readonly config;
+    private readonly cacheStore;
+    /** Metadata API operations */
+    readonly metadata: MetadataAPI;
+    /** Records CRUD operations */
+    readonly records: RecordsAPI;
+    /** Batch operations */
+    readonly batch: BatchAPI;
+    /** Field management operations */
+    readonly fields: FieldsAPI;
+    /** File operations */
+    readonly files: FilesAPI;
+    /**
+     * Creates a new FireberryClient instance
+     */
+    constructor(config: FireberryClientConfig);
+    /**
+     * Gets the client configuration
+     */
+    getConfig(): Readonly<Required<FireberryClientConfig>>;
+    /**
+     * Cache control methods
+     */
+    readonly cache: CacheControl;
+    /**
+     * Gets cached data if valid, or undefined if not cached or expired
+     */
+    getCached<T>(type: 'objects'): T | undefined;
+    getCached<T>(type: 'fields', objectType: string): T | undefined;
+    getCached<T>(type: 'fieldValues', objectType: string, fieldName: string): T | undefined;
+    /**
+     * Sets cached data
+     */
+    setCache(type: 'objects', data: unknown): void;
+    setCache(type: 'fields', objectType: string, data: unknown): void;
+    setCache(type: 'fieldValues', objectType: string, fieldName: string, data: unknown): void;
+    /**
+     * Creates a new QueryBuilder instance
+     */
+    queryBuilder(): QueryBuilder;
+    /**
+     * Executes a query against the Fireberry API
+     */
+    query(options: QueryOptions): Promise<QueryResult>;
+    /**
+     * Fetches all pages of a query
+     */
+    private queryAllPages;
+    /**
+     * Expands '*' fields to actual field names, excluding problematic fields for specific object types
+     */
+    private expandStarFields;
+    /**
+     * Makes a raw API request to the Fireberry API
+     */
+    request<T = unknown>(options: RequestOptions): Promise<T>;
+    /**
+     * Executes a fetch request with retry logic for 429 errors
+     */
+    private executeWithRetry;
+    /**
+     * Combines multiple abort signals into one
+     */
+    private combineSignals;
+}
+
+/**
+ * Error codes for Fireberry API errors
+ */
+declare enum FireberryErrorCode {
+    /** Unknown or unexpected error */
+    UNKNOWN = "UNKNOWN",
+    /** Network error (connection failed, DNS, etc.) */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Request timeout */
+    TIMEOUT = "TIMEOUT",
+    /** Authentication failed (invalid API key) */
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    /** Authorization failed (missing permissions) */
+    AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED",
+    /** Resource not found */
+    NOT_FOUND = "NOT_FOUND",
+    /** Rate limit exceeded (429) */
+    RATE_LIMITED = "RATE_LIMITED",
+    /** Invalid request parameters */
+    INVALID_REQUEST = "INVALID_REQUEST",
+    /** Server error (5xx) */
+    SERVER_ERROR = "SERVER_ERROR",
+    /** Request was aborted */
+    ABORTED = "ABORTED",
+    /** Invalid response from API */
+    INVALID_RESPONSE = "INVALID_RESPONSE"
+}
+/**
+ * Options for creating a FireberryError
+ */
+interface FireberryErrorOptions {
+    /** Error code */
+    code: FireberryErrorCode;
+    /** HTTP status code if applicable */
+    statusCode?: number;
+    /** Original error that caused this error */
+    cause?: Error;
+    /** Additional context data */
+    context?: Record<string, unknown>;
+}
+/**
+ * Custom error class for Fireberry API errors
+ */
+declare class FireberryError extends Error {
+    /** Error code */
+    readonly code: FireberryErrorCode;
+    /** HTTP status code if applicable */
+    readonly statusCode?: number;
+    /** Original error that caused this error */
+    readonly cause?: Error;
+    /** Additional context data */
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, options: FireberryErrorOptions);
+    /**
+     * Creates a string representation of the error
+     */
+    toString(): string;
+    /**
+     * Converts the error to a plain object for logging/serialization
+     */
+    toJSON(): Record<string, unknown>;
+}
+
+export { type BatchCreateOptions, type BatchDeleteOptions, type BatchDeleteResult, type BatchResult, type BatchUpdateOptions, type BatchUpdateRecord, type CacheControl, type CreateFieldOptions, type CreateFieldOptionsBase, type CreateFieldResult, type CreateFieldType, type CreateFormulaFieldOptions, type CreateLookupFieldOptions, type CreateNumberFieldOptions, type CreateOptions, type CreatePicklistFieldOptions, type CreateSimpleFieldOptions, type CreateSummaryFieldOptions, type CreateTextFieldOptions, type DeleteOptions, type FieldValue, type FileUploadOptions, type FileUploadResult, FireberryClient, type FireberryClientConfig, FireberryError, FireberryErrorCode, type FireberryErrorOptions, type FireberryField, type FireberryObject, type FireberryRecord, type FormulaFieldType, type GetFieldValuesResult, type GetFieldsResult, type GetObjectsResult, type PicklistValue, QueryBuilder, type QueryConditionItem, type QueryItem, type QueryOperator, type QueryOptions, type QueryResult, type QuerySeparatorItem, type RequestOptions, type SummaryType, type UpdateOptions, type UpsertOptions, type UpsertResult };