@cargo-ai/types 1.0.1 → 1.0.3

package/build/src/systemOfRecordIntegration/systemOfRecordIntegration.d.ts

@@ -0,0 +1,777 @@
+import { type Schema as JsonSchema } from "jsonschema";
+import { type BigQueryClientTypes } from "./clients/bigQuery.js";
+import { type SnowflakeClientTypes } from "./clients/snowflake.js";
+export declare namespace SystemOfRecordIntegrationTypes {
+    type BigQueryConfig = BigQueryClientTypes.BigQueryConfig;
+    type BigQueryScopeConfig = BigQueryClientTypes.BigQueryScopeConfig;
+    type SnowflakeConfig = SnowflakeClientTypes.SnowflakeConfig;
+    type SnowflakeScopeConfig = SnowflakeClientTypes.SnowflakeScopeConfig;
+    type SystemOfRecordKind = "bigQuery" | "snowflake";
+    type SystemOfRecordConfig = BigQueryConfig | SnowflakeConfig;
+    type MigrationStatus = "success" | "error" | "running";
+    type Migration = {
+        uuid: string;
+        workspaceUuid: string;
+        systemOfRecordUuid: string;
+        filename: string;
+        finishedAt: Date | null;
+        updatedAt: Date;
+        createdAt: Date;
+        status: MigrationStatus;
+        errorMessage: string | null;
+    };
+    type CutoverStatus = "running" | "success" | "error";
+    type Cutover = {
+        uuid: string;
+        workspaceUuid: string;
+        sourceSystemOfRecordUuid: string;
+        targetSystemOfRecordUuid: string;
+        status: CutoverStatus;
+        errorMessage: string | null;
+        tablesTotal: number;
+        tablesMigrated: number;
+        finishedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    type Usage = {
+        date: Date;
+        processedSecondsCount: number;
+        processedBytesCount: number;
+        queriesCount: number;
+    };
+    type SystemOfRecord = {
+        uuid: string;
+        workspaceUuid: string;
+        kind: SystemOfRecordKind;
+        config: SystemOfRecordConfig;
+        lastMigration: {
+            uuid: string;
+            finishedAt: Date | null;
+            createdAt: Date;
+            status: MigrationStatus;
+            errorMessage: string | null;
+        } | null;
+        cutover: {
+            uuid: string;
+            role: "source" | "target";
+            sourceSystemOfRecordUuid: string;
+            targetSystemOfRecordUuid: string;
+            status: CutoverStatus;
+            errorMessage: string | null;
+            tablesTotal: number;
+            tablesMigrated: number;
+            finishedAt: Date | null;
+            createdAt: Date;
+        } | null;
+        useCredits: boolean;
+        isActive: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+    };
+    type LogStatus = "success" | "error";
+    type Log = {
+        uuid: string;
+        workspaceUuid: string;
+        systemOfRecordUuid: string;
+        query: string;
+        status: LogStatus;
+        processedBytesCount: number;
+        errorMessage: string | null;
+        startedAt: Date;
+        finishedAt: Date;
+        createdAt: Date;
+    };
+    type ObjectType = "account" | "contact" | "accountEvent" | "contactEvent";
+    type Column = {
+        slug: string;
+        type: ColumnType;
+    };
+    type ColumnWithFunction = Column & {
+        function?: Table;
+        args?: string | string[];
+        query?: string;
+    };
+    type DetailedColumn = Column & {
+        isNullable: boolean;
+        hasDefault: boolean;
+        isPrimaryKey: boolean;
+        isUniqueKey: boolean;
+    };
+    type ColumnMapping = {
+        slug: string;
+        alias: string;
+    };
+    type ColumnType = "string" | "number" | "object" | "array" | "date" | "boolean" | "vector" | "any";
+    type ColumnKind = "computed" | "custom" | "metric" | "lookup" | "original";
+    type Table = {
+        database: string;
+        schema: string;
+        name: string;
+    };
+    type Schema = {
+        database: string;
+        name: string;
+    };
+    type RecordsBatch = {
+        database: string;
+        schema: string;
+        table: string;
+        idColumnSlug: string;
+        action: "update" | "upsert" | "remove" | "insert";
+        override: boolean;
+    };
+    type PushFromSqsToStreamResult = {
+        outcome: "pushed";
+    } | {
+        outcome: "notPushed";
+        errorMessage: string;
+    };
+    type InsertFromStreamResult = {
+        outcome: "inserted";
+        insertedBatches: RecordsBatch[];
+        failedBatches: RecordsBatch[];
+    } | {
+        outcome: "notInserted";
+        errorMessage: string;
+    };
+    type InsertFromStreamCondition = {
+        kind: "table";
+        operator: "is" | "isNot";
+        table: Table;
+    } | {
+        kind: "schema";
+        operator: "is" | "isNot";
+        schema: Schema;
+    } | {
+        kind: "database";
+        operator: "is" | "isNot";
+        database: string;
+    };
+    type GetCountResult = {
+        outcome: "counted";
+        count: number;
+    } | {
+        outcome: "notCounted";
+        errorMessage: string;
+    };
+    type DownloadResult = {
+        outcome: "downloaded";
+        urls: string[];
+        uris: string[];
+    } | {
+        outcome: "notDownloaded";
+        errorMessage: string;
+    };
+    type DownloadOptions = {
+        expireAt?: Date;
+        format?: "csv" | "parquet";
+    };
+    type CreateTableFromUrisResult = {
+        outcome: "inserted";
+        rowsInserted: number;
+    } | {
+        outcome: "notInserted";
+        errorMessage: string;
+    };
+    type InsertFromUriOptions = {
+        format?: "csv" | "parquet";
+    };
+    type FetchOptions = {
+        limit?: number;
+        offset?: number;
+        sort?: {
+            columnSlug: string;
+            kind: "asc" | "desc";
+        }[];
+    };
+    type FetchResult = {
+        outcome: "fetched";
+        count: number;
+        records: Record<string, any>[];
+    } | {
+        outcome: "notFetched";
+        errorMessage: string;
+    };
+    type QueryResult = {
+        outcome: "queried";
+        rows: Record<string, any>[];
+    } | {
+        outcome: "notQueried";
+        errorMessage: string;
+    };
+    type QueryOptions = {
+        readOnly?: boolean;
+    };
+    type IsValidResult = {
+        outcome: "valid";
+    } | {
+        outcome: "notValid";
+        errorMessage: string;
+    };
+    type SetupResult = {
+        outcome: "setup";
+        config: SystemOfRecordConfig;
+    } | {
+        outcome: "notSetup";
+        errorMessage: string;
+    };
+    type CheckHasPermissionsResult = {
+        outcome: "valid";
+    } | {
+        outcome: "notValid";
+        errorMessage: string;
+    };
+    type TestConnectionResult = {
+        outcome: "connected";
+    } | {
+        outcome: "notConnected";
+        errorMessage: string;
+    };
+    type StreamHandle = (record: Record<string, any>) => Promise<void>;
+    type StreamOnStart = (payload: {
+        queryId: string;
+    }) => Promise<void>;
+    type StreamResult = {
+        outcome: "streamed";
+    } | {
+        outcome: "notStreamed";
+        errorMessage: string;
+    };
+    type GetColumnsResult = {
+        outcome: "retrieved";
+        columns: DetailedColumn[];
+    } | {
+        outcome: "notRetrieved";
+        errorMessage: string;
+    };
+    type CreateTableOptions = {
+        rule?: "createIfDoesntExist" | "replaceIfExists";
+        materialization?: "table" | "view";
+        isTemporary?: boolean;
+        expirationHours?: number;
+    };
+    type CreateTableResult = {
+        outcome: "created";
+        columns: DetailedColumn[];
+    } | {
+        outcome: "notCreated";
+        errorMessage: string;
+    };
+    type CreateTableDiffResult = {
+        outcome: "created";
+        addedRecordsCount: number;
+        updatedRecordsCount: number;
+        unchangedRecordsCount: number;
+        removedRecordsCount: number;
+    } | {
+        outcome: "notCreated";
+        errorMessage: string;
+    };
+    type DropTableOptions = {
+        rule?: "ifExists";
+    };
+    type GetTableDdlOptions = {
+        materialization?: "table" | "view";
+    };
+    type DropTableResult = {
+        outcome: "dropped";
+    } | {
+        outcome: "notDropped";
+        errorMessage: string;
+    };
+    type RenameTableResult = {
+        outcome: "renamed";
+    } | {
+        outcome: "notRenamed";
+        errorMessage: string;
+    };
+    type CreateTableDiffOptions = {
+        excludedColumnSlugs?: string[];
+        includedColumnSlugs?: string[];
+    };
+    type CreateSchemaResult = {
+        outcome: "created";
+    } | {
+        outcome: "notCreated";
+        errorMessage: string;
+    };
+    type DropSchemaResult = {
+        outcome: "dropped";
+    } | {
+        outcome: "notDropped";
+        errorMessage: string;
+    };
+    type ClientManifest = {
+        name: string;
+        slug: string;
+        icon: string;
+        description: string;
+        config: {
+            jsonSchema: JsonSchema;
+            uiSchema?: Record<string, any>;
+        };
+    };
+    type FilterConjonction = "or" | "and";
+    type FilterConditionKind = "sql" | "string" | "number" | "object" | "array" | "vector" | "any" | "date" | "boolean" | "occurrence" | "enrollment" | "segment" | "objectProperty";
+    type FilterConditionSql = {
+        kind: "sql";
+        name: string;
+        clause: string;
+    };
+    type FilterConditionString = {
+        kind: "string";
+        relatedModelUuid?: string;
+        columnSlug: string;
+    } & ({
+        operator: "is" | "isNot" | "contains" | "doesNotContain" | "startsWith" | "endsWith";
+        values: string[] | string;
+    } | {
+        operator: "isNull" | "isNotNull" | "isEmpty" | "isNotEmpty";
+    });
+    type FilterConditionNumber = {
+        kind: "number";
+        relatedModelUuid?: string;
+        columnSlug: string;
+    } & ({
+        operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+        value: number;
+    } | {
+        operator: "between";
+        firstValue: number;
+        lastValue: number;
+    } | {
+        operator: "isNull" | "isNotNull";
+    });
+    type FilterConditionObjectPropertyOperator = "is" | "isNot" | "contains" | "greaterThan" | "lowerThan" | "doesNotContain" | "startsWith" | "endsWith" | "isNull" | "isNotNull" | "between";
+    type FilterConditionObjectProperty = {
+        kind: "objectProperty";
+        relatedModelUuid?: string;
+        columnSlug: string;
+        propertyName: string;
+    } & ({
+        operator: Exclude<FilterConditionObjectPropertyOperator, "isNull" | "isNotNull" | "between">;
+        value: string;
+    } | {
+        operator: "isNotNull" | "isNull" | "isEmpty" | "isNotEmpty";
+    } | {
+        operator: "between";
+        value: string;
+        otherValue: string;
+    });
+    type FilterConditionObject = {
+        kind: "object";
+        relatedModelUuid?: string;
+        columnSlug: string;
+    } & ({
+        operator: "isNull";
+    } | {
+        operator: "isNotNull";
+    } | {
+        operator: "matchConditions";
+        conjonction: FilterConjonction;
+        propertyConditions: FilterConditionObjectProperty[];
+    });
+    type FilterConditionArray = {
+        kind: "array";
+        relatedModelUuid?: string;
+        columnSlug: string;
+    } & ({
+        operator: "isNull";
+    } | {
+        operator: "isNotNull";
+    } | {
+        operator: "matchConditions";
+        conjonction: FilterConjonction;
+        propertyConditions: FilterConditionObjectProperty[];
+    });
+    type FilterConditionVector = {
+        kind: "vector";
+        relatedModelUuid?: string;
+        columnSlug: string;
+        operator: "isNull" | "isNotNull";
+    };
+    type FilterConditionAny = {
+        kind: "any";
+        relatedModelUuid?: string;
+        columnSlug: string;
+        operator: "isNull" | "isNotNull";
+    };
+    type FilterConditionDate = {
+        kind: "date";
+        relatedModelUuid?: string;
+        columnSlug: string;
+    } & ({
+        operator: "is" | "isNot" | "greaterThan" | "lowerThan";
+        value: string;
+    } | {
+        operator: "between";
+        firstValue: string;
+        lastValue: string;
+    } | {
+        operator: "isNull" | "isNotNull";
+    });
+    type FilterConditionBoolean = {
+        relatedModelUuid?: string;
+        kind: "boolean";
+        columnSlug: string;
+        operator: "isTrue" | "isFalse" | "isNull" | "isNotNull";
+    };
+    type FilterConditionSegment = {
+        kind: "segment";
+        segmentUuid: string;
+        operator: "in" | "notIn";
+    };
+    type FilterConditionOccurrenceFrequency = {
+        operator: "not";
+    } | {
+        operator: "moreThan" | "lessThan" | "exactly";
+        value: number;
+    };
+    type FilterConditionOccurrencePeriod = {
+        operator: "lessThan" | "moreThan" | "exactly";
+        value: number;
+        unit: "day";
+    };
+    type FilterConditionOccurrence = {
+        kind: "occurrence";
+        relatedModelUuid: string;
+        frequency: FilterConditionOccurrenceFrequency;
+        period: FilterConditionOccurrencePeriod;
+        conjonction: FilterConjonction;
+        conditions: (FilterConditionString | FilterConditionNumber | FilterConditionObject | FilterConditionArray | FilterConditionAny | FilterConditionVector | FilterConditionDate | FilterConditionBoolean)[];
+    };
+    type FilterConditionEnrollmentActivityKind = "workflowEntered" | "workflowNodeExecuted" | "workflowLeft";
+    type FilterConditionEnrollmentFrequency = {
+        operator: "not";
+    } | {
+        operator: "moreThan" | "lessThan" | "exactly";
+        value: number;
+    };
+    type FilterConditionEnrollmentPeriod = {
+        operator: "lessThan" | "moreThan" | "exactly";
+        value: number;
+        unit: "day";
+    };
+    type FilterConditionEnrollment = {
+        kind: "enrollment";
+        workflowUuid: string;
+        activityKind: FilterConditionEnrollmentActivityKind;
+        nodeSlug?: string;
+        frequency: FilterConditionEnrollmentFrequency;
+        period: FilterConditionEnrollmentPeriod;
+    };
+    type FilterCondition = FilterConditionSql | FilterConditionString | FilterConditionNumber | FilterConditionObject | FilterConditionArray | FilterConditionAny | FilterConditionVector | FilterConditionDate | FilterConditionBoolean | FilterConditionOccurrence | FilterConditionEnrollment | FilterConditionSegment | FilterConditionObjectProperty;
+    type FilterGroup = {
+        conjonction: FilterConjonction;
+        conditions: FilterCondition[];
+    };
+    type Filter = {
+        conjonction: FilterConjonction;
+        groups: FilterGroup[];
+    };
+    type Sort = {
+        columnSlug: string;
+        kind: "asc" | "desc";
+    }[];
+    type AggregationFunction = "AVG" | "COUNT" | "MAX" | "MIN" | "SUM" | "ANY_VALUE";
+    type ModelRelationship = {
+        rightModelUuid: string;
+        leftColumn: string;
+        rightColumn: string;
+    };
+    type ModelColumn = Column & {
+        originalSlug: string;
+    };
+    type Model = {
+        uuid: string;
+        slug: string;
+        datasetUuid: string;
+        datasetSlug: string;
+        idColumnSlug: string;
+        titleColumnSlug: string;
+        timeColumnSlug?: string;
+        columns: ModelColumn[];
+        customColumns: Column[];
+        hasOneRelationships: ModelRelationship[];
+    };
+    type Segment = {
+        name: string;
+        uuid: string;
+        slug: string;
+    };
+    type DetailedRecordMeta = {
+        storage?: {
+            runUuid: string;
+        };
+    };
+    type DetailedRecord = {
+        database: string;
+        schema: string;
+        table: string;
+        columns: Column[];
+        idColumnSlug: string;
+        override: boolean;
+        data: Record<string, any>;
+        action: "update" | "upsert" | "remove" | "insert";
+        mode: "sync" | "async";
+        meta?: DetailedRecordMeta;
+        emittedAt: Date;
+    };
+    type SimpleRecord = {
+        database: string;
+        schema: string;
+        table: string;
+        data: Record<string, any>;
+    } & ({
+        action: "update" | "upsert" | "remove";
+        idColumnSlug: string;
+    } | {
+        action: "insert";
+    });
+    type FilterModel = {
+        uuid: string;
+        slug: string;
+        datasetSlug: string;
+    };
+    type FilterRelationship = {
+        rightModelUuid: string;
+        rightDatasetSlug: string;
+        rightModelSlug: string;
+        rightColumnSlug: string;
+        leftColumnSlug: string;
+        timeColumnSlug?: string;
+    };
+    type WhereConditionKind = ColumnType | "reference" | "query";
+    type WhereCondition = {
+        kind: "number" | "date";
+        columnSlug: string;
+        operator: "lowerThan" | "lowerThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "is" | "isNot";
+        value: any;
+    } | {
+        kind: "number" | "date";
+        columnSlug: string;
+        operator: "between";
+        value: any;
+        otherValue: any;
+    } | {
+        kind: "string";
+        columnSlug: string;
+        operator: "is" | "isNot" | "contains" | "notContains";
+        values: any | any[];
+    } | {
+        kind: "boolean";
+        columnSlug: string;
+        operator: "is" | "isNot";
+        value: any;
+    } | {
+        kind: "reference";
+        columnSlug: string;
+        operator: "is" | "isNot";
+        value: string;
+        outerTableAlias?: string;
+    } | {
+        kind: "query";
+        operator: "is" | "isNot";
+        value: string;
+    } | {
+        kind: Exclude<WhereConditionKind, "query">;
+        columnSlug: string;
+        operator: "isNotNull" | "isNull";
+    };
+    type WhereConjunction = "or" | "and";
+    type Where = {
+        conjunction: WhereConjunction;
+        groups: {
+            conjunction: WhereConjunction;
+            conditions: WhereCondition[];
+        }[];
+    };
+    type GetTableSelectColumn = {
+        kind: "column";
+        slug: string;
+        alias?: string;
+    } | {
+        kind: "aggregation";
+        function: AggregationFunction;
+        columnSlug: string;
+        alias?: string;
+    };
+    type GetTableQueryPayload = {
+        table: Table;
+        where?: Where;
+        select?: GetTableSelectColumn[];
+        groupBy?: string[];
+        sort?: Sort;
+        limit?: number;
+    };
+    type GetModelQueryPayload = {
+        models: Model[];
+        rootModelUuid: string;
+    };
+    type GetEnrichedModelQueryPayload = {
+        query: string;
+        segments: Segment[];
+    };
+    type GetActivitiesFromChangeQueryPayload = {
+        segmentSlug: string;
+        changeSlug: string;
+        modelUuid: string;
+        segmentUuid: string;
+        changeUuid: string;
+    };
+    type GetModelWhereQueryPayload = {
+        relationships: FilterRelationship[];
+        model: FilterModel;
+        segments: Segment[];
+        filter: Filter;
+    };
+    type GetDailyAllocationsQueryPayload = {
+        subQuery: string;
+        connectorSlugsToColumnSlugMapping: Record<string, string>;
+        idColumnSlug: string;
+        timeColumnSlug: string;
+    };
+    type MergeUnificationMappingsQueryReshaper = "urlExtractDomain" | "urlExtractLinkedinIdOrHandle" | "urlExtractCrunchbaseId" | "urlExtractTwitterHandle" | "urlExtractSalesNavigatorId";
+    type MergeUnificationMappingsQueryPayload = {
+        unificationType: "account" | "contact" | "accountEvent" | "contactEvent";
+        datasetSlug: string;
+        modelSlug: string;
+        idColumnSlug: string;
+        uniqueColumns: {
+            slug: string;
+            reference: string;
+            reshaper?: MergeUnificationMappingsQueryReshaper;
+        }[];
+    };
+    type FunctionLanguage = "js" | "sql";
+    type ClientQueries = {
+        getModel: (payload: GetModelQueryPayload) => string;
+        getEnrichedModel: (payload: GetEnrichedModelQueryPayload) => string;
+        getModelWhere: (payload: GetModelWhereQueryPayload) => string | undefined;
+        getTable: (payload: GetTableQueryPayload) => string;
+        getActivitiesFromChange: (payload: GetActivitiesFromChangeQueryPayload) => string;
+        getDailyAllocations: (payload: GetDailyAllocationsQueryPayload) => string;
+        mergeUnificationMappings: (payload: MergeUnificationMappingsQueryPayload) => string | undefined;
+        migration: {
+            getTablesToMigrate: () => string;
+        };
+    };
+    type ClientReferences = {
+        database: string;
+        schema: Schema | undefined;
+        parseSchema: (schema: Schema) => string;
+        parseTable: (table: Table) => string;
+        getSchema: (schema: string) => Schema | undefined;
+        getTable: (schema: string, name: string) => Table;
+        isValidTable: (table: Table) => boolean;
+        computation: {
+            getSchema: () => Schema | undefined;
+            getTable: (name: string) => Table;
+            streams: {
+                getTable: () => Table;
+            };
+            activities: {
+                getTable: () => Table;
+                getColumns: () => Column[];
+            };
+            unificationMappings: {
+                getTable: () => Table;
+                getColumns: () => Column[];
+            };
+        };
+        storage: {
+            dataset: (slug: string) => {
+                getSchema: () => Schema | undefined;
+            };
+            model: (datasetSlug: string, slug: string) => {
+                getSourceTable: () => Table;
+                getCustomTable: () => Table;
+                getActivitiesTable: () => Table;
+                getStagingTable: () => Table;
+                getTable: () => Table;
+                getComputedColumnFunction: (columnSlug: string) => Table;
+            };
+            column: {
+                isValid: (columnSlug: string) => boolean;
+                match: (columnSlug: string, columns: Column[]) => Column | undefined;
+                getDiff: (currentColumns: Column[], newColumns: Column[]) => Column[];
+                getSlug: (slug: string, kind: ColumnKind, prefix?: string) => string;
+            };
+        };
+        segmentation: {
+            segment: (slug: string) => {
+                getSchema: () => Schema | undefined;
+                getTable: () => Table;
+                getReferenceTable: () => Table;
+            };
+            change: (segmentSlug: string, slug: string) => {
+                getTable: () => Table;
+            };
+        };
+    };
+    type AddColumnsOptions = {
+        outerTableAlias?: string;
+    };
+    type AddColumnsResult = {
+        outcome: "added";
+    } | {
+        outcome: "notAdded";
+        errorMessage: string;
+    };
+    type AlterColumnsOptions = {
+        outerTableAlias?: string;
+    };
+    type AlterColumnsResult = {
+        outcome: "altered";
+    } | {
+        outcome: "notAltered";
+        errorMessage: string;
+    };
+    interface Client {
+        kind: string;
+        references: ClientReferences;
+        queries: ClientQueries;
+        testConnection(): Promise<TestConnectionResult>;
+        isEmpty(): Promise<boolean>;
+        setup(): Promise<SetupResult>;
+        checkHasPermissions(): Promise<CheckHasPermissionsResult>;
+        upsertFunction(table: Table, code: string, language: FunctionLanguage, outputType: SystemOfRecordIntegrationTypes.ColumnType): Promise<void>;
+        removeFunction(table: Table, language: FunctionLanguage): Promise<void>;
+        getObjectColumnProperties(table: Table, columnSlug: string): Promise<string[]>;
+        getArrayColumnObjectProperties(table: Table, columnSlug: string): Promise<string[]>;
+        query(query: string, options?: QueryOptions): Promise<QueryResult>;
+        isValid(query: string): Promise<IsValidResult>;
+        bulkInsert(records: DetailedRecord[]): Promise<void>;
+        insertOne(record: SimpleRecord): Promise<void>;
+        pushFromSqsToStream: (s3Key: string) => Promise<PushFromSqsToStreamResult>;
+        insertFromStream(conditions?: InsertFromStreamCondition[]): Promise<InsertFromStreamResult>;
+        getCount(query: string): Promise<GetCountResult>;
+        download(query: string, options?: DownloadOptions): Promise<DownloadResult>;
+        fetch(query: string, options?: FetchOptions): Promise<FetchResult>;
+        stream(payload: {
+            query?: string;
+            queryId?: string;
+            handle: StreamHandle;
+            onStart?: StreamOnStart;
+        }): Promise<StreamResult>;
+        getColumns(table: Table, reset?: boolean): Promise<GetColumnsResult>;
+        addColumns(table: Table, columns: ColumnWithFunction[], options?: AddColumnsOptions): Promise<AddColumnsResult>;
+        alterColumns(table: Table, columns: ColumnWithFunction[], options?: AlterColumnsOptions): Promise<AlterColumnsResult>;
+        dropColumns(table: Table, columnSlugs: string[]): Promise<void>;
+        getTableDdl: (table: Table, options?: GetTableDdlOptions) => Promise<string | undefined>;
+        createTable(table: Table, query: string, options?: CreateTableOptions): Promise<CreateTableResult>;
+        createTableWithColumns(table: Table, columns: Column[], options?: CreateTableOptions): Promise<CreateTableResult>;
+        createTableFromUris(table: Table, uris: string[], options?: InsertFromUriOptions): Promise<CreateTableFromUrisResult>;
+        dropTable(table: Table, options?: DropTableOptions): Promise<DropTableResult>;
+        renameTable(table: Table, newName: string): Promise<RenameTableResult>;
+        createTableDiff(defaultTable: Table, referenceTable: Table, diffTable: Table, idColumnSlug: string, options?: CreateTableDiffOptions): Promise<CreateTableDiffResult>;
+        checkTableExists(table: Table): Promise<boolean>;
+        insert(table: Table, columnSlugs: string[], query: string): Promise<void>;
+        createSchema(schema: Schema, replaceIfExists?: boolean): Promise<CreateSchemaResult>;
+        dropSchema(schema: Schema): Promise<DropSchemaResult>;
+        getColumnValues(table: Table, column: Column): Promise<string[]>;
+    }
+}
+//# sourceMappingURL=systemOfRecordIntegration.d.ts.map