@osdk/foundry.connectivity 2.16.0 → 2.18.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @osdk/foundry.connectivity
 
+## 2.18.0
+
+### Minor Changes
+
+- 98ec492: Update Platform SDKs
+
+### Patch Changes
+
+- Updated dependencies [98ec492]
+  - @osdk/foundry.orchestration@2.18.0
+  - @osdk/foundry.filesystem@2.18.0
+  - @osdk/foundry.datasets@2.18.0
+  - @osdk/foundry.core@2.18.0
+
+## 2.17.0
+
+### Minor Changes
+
+- db7ee48: Update Platform SDKs
+
+### Patch Changes
+
+- Updated dependencies [db7ee48]
+  - @osdk/foundry.orchestration@2.17.0
+  - @osdk/foundry.filesystem@2.17.0
+  - @osdk/foundry.datasets@2.17.0
+  - @osdk/foundry.core@2.17.0
+
 ## 2.16.0
 
 ### Minor Changes

package/build/browser/_components.d.ts

@@ -4,37 +4,12 @@ import type * as _Filesystem from "@osdk/foundry.filesystem";
 export type LooselyBrandedString<T extends string> = string & {
     __LOOSE_BRAND?: T;
 };
-/**
-   * The agent proxy runtime is used to connect
-to data sources not accessible over the Internet. The agent acts as an inverting network proxy, forwarding
-network traffic originating in Foundry into the network where the agent is deployed, and relaying traffic
-back to Foundry. This allows capabilities in Foundry to work almost exactly the same as when using a
-direct connection but without requiring you to allow inbound network traffic to your systems originating
-from Foundry's IP addresses.
-   *
-   * Log Safety: UNSAFE
-   */
-export interface AgentProxyRuntime {
-    agentRids: Array<AgentRid>;
-}
 /**
  * The Resource Identifier (RID) of an Agent.
  *
  * Log Safety: UNSAFE
  */
 export type AgentRid = LooselyBrandedString<"AgentRid">;
-/**
-   * The agent worker runtime is used to
-connect to data sources not accessible over the Internet. An agent worker should only be used when the desired
-connector does not support the agent proxy runtime. Agent worker runtimes are associated with a single or
-multiple agents that store the source configuration and credentials locally in an encrypted format,
-and run source capabilities on the agent itself.
-   *
-   * Log Safety: UNSAFE
-   */
-export interface AgentWorkerRuntime {
-    agentRids: Array<AgentRid>;
-}
 /**
    * The API key used to authenticate to the external system.
 This can be configured as a header or query parameter.
@@ -70,6 +45,17 @@ export interface AwsAccessKey {
     accessKeyId: string;
     secretAccessKey: EncryptedProperty;
 }
+/**
+   * OpenID Connect (OIDC) is an open authentication protocol that allows
+you to authenticate to external system resources without the use of static credentials.
+   *
+   * Log Safety: UNSAFE
+   */
+export interface AwsOidcAuthentication {
+    audience: string;
+    issuerUrl: string;
+    subject: ConnectionRid;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -107,7 +93,6 @@ export interface Connection {
     rid: ConnectionRid;
     parentFolderRid: _Filesystem.FolderRid;
     displayName: ConnectionDisplayName;
-    runtimePlatform: RuntimePlatform;
     configuration: ConnectionConfiguration;
 }
 /**
@@ -117,7 +102,11 @@ export type ConnectionConfiguration = ({
     type: "s3";
 } & S3ConnectionConfiguration) | ({
     type: "rest";
-} & RestConnectionConfiguration);
+} & RestConnectionConfiguration) | ({
+    type: "snowflake";
+} & SnowflakeConnectionConfiguration) | ({
+    type: "jdbc";
+} & JdbcConnectionConfiguration);
 /**
  * The display name of the Connection. The display name must not be blank.
  *
@@ -135,22 +124,9 @@ export type ConnectionRid = LooselyBrandedString<"ConnectionRid">;
  */
 export interface CreateConnectionRequest {
     parentFolderRid: _Filesystem.FolderRid;
-    runtimePlatform: CreateConnectionRequestRuntimePlatform;
     configuration: CreateConnectionRequestConnectionConfiguration;
     displayName: ConnectionDisplayName;
 }
-/**
- * Log Safety: UNSAFE
- */
-export interface CreateConnectionRequestAgentProxyRuntime {
-    agentRids: Array<AgentRid>;
-}
-/**
- * Log Safety: UNSAFE
- */
-export interface CreateConnectionRequestAgentWorkerRuntime {
-    agentRids: Array<AgentRid>;
-}
 /**
  * Log Safety: DO_NOT_LOG
  */
@@ -170,6 +146,12 @@ export interface CreateConnectionRequestAwsAccessKey {
     accessKeyId: string;
     secretAccessKey: CreateConnectionRequestEncryptedProperty;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateConnectionRequestAwsOidcAuthentication {
+    audience: string;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -190,13 +172,11 @@ export type CreateConnectionRequestConnectionConfiguration = ({
     type: "s3";
 } & CreateConnectionRequestS3ConnectionConfiguration) | ({
     type: "rest";
-} & CreateConnectionRequestRestConnectionConfiguration);
-/**
- * Log Safety: SAFE
- */
-export interface CreateConnectionRequestDirectConnectionRuntime {
-    networkEgressPolicyRids: Array<NetworkEgressPolicyRid>;
-}
+} & CreateConnectionRequestRestConnectionConfiguration) | ({
+    type: "snowflake";
+} & CreateConnectionRequestSnowflakeConnectionConfiguration) | ({
+    type: "jdbc";
+} & CreateConnectionRequestJdbcConnectionConfiguration);
 /**
  * Log Safety: SAFE
  */
@@ -222,8 +202,11 @@ export type CreateConnectionRequestEncryptedProperty = ({
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateConnectionRequestOidc {
-    audience: string;
+export interface CreateConnectionRequestJdbcConnectionConfiguration {
+    credentials?: BasicCredentials;
+    driverClass: string;
+    jdbcProperties: Record<string, string>;
+    url: string;
 }
 /**
    * When creating or updating additional secrets, use SecretsWithPlaintextValues.
@@ -244,19 +227,6 @@ export interface CreateConnectionRequestRestConnectionConfiguration {
     oauth2ClientRid?: string;
     domains: Array<Domain>;
 }
-/**
-   * The runtime of a Connection, which defines the
-networking configuration and where capabilities are executed.
-   *
-   * Log Safety: UNSAFE
-   */
-export type CreateConnectionRequestRuntimePlatform = ({
-    type: "directConnectionRuntime";
-} & CreateConnectionRequestDirectConnectionRuntime) | ({
-    type: "agentProxyRuntime";
-} & CreateConnectionRequestAgentProxyRuntime) | ({
-    type: "agentWorkerRuntime";
-} & CreateConnectionRequestAgentWorkerRuntime);
 /**
  * Log Safety: UNSAFE
  */
@@ -266,7 +236,7 @@ export type CreateConnectionRequestS3AuthenticationMode = ({
     type: "cloudIdentity";
 } & CreateConnectionRequestCloudIdentity) | ({
     type: "oidc";
-} & CreateConnectionRequestOidc);
+} & CreateConnectionRequestAwsOidcAuthentication);
 /**
  * Log Safety: UNSAFE
  */
@@ -314,6 +284,40 @@ export interface CreateConnectionRequestSecretsNames {
 export interface CreateConnectionRequestSecretsWithPlaintextValues {
     secrets: Record<SecretName, PlaintextValue>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export type CreateConnectionRequestSnowflakeAuthenticationMode = ({
+    type: "externalOauth";
+} & CreateConnectionRequestSnowflakeExternalOauth) | ({
+    type: "keyPair";
+} & CreateConnectionRequestSnowflakeKeyPairAuthentication) | ({
+    type: "basic";
+} & CreateConnectionRequestBasicCredentials);
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateConnectionRequestSnowflakeConnectionConfiguration {
+    schema?: string;
+    database?: string;
+    role?: string;
+    accountIdentifier: string;
+    jdbcProperties: Record<string, string>;
+    warehouse?: string;
+    authenticationMode: CreateConnectionRequestSnowflakeAuthenticationMode;
+}
+/**
+ * Log Safety: SAFE
+ */
+export interface CreateConnectionRequestSnowflakeExternalOauth {
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateConnectionRequestSnowflakeKeyPairAuthentication {
+    privateKey: CreateConnectionRequestEncryptedProperty;
+    user: string;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -349,32 +353,79 @@ export interface CreateTableImportRequest {
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestJdbcImportConfig {
-    query: string;
+export interface CreateTableImportRequestDateColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestMicrosoftAccessImportConfig {
-    query: string;
+export interface CreateTableImportRequestDecimalColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestMicrosoftSqlServerImportConfig {
-    query: string;
+export interface CreateTableImportRequestIntegerColumnInitialIncrementalState {
+    currentValue: number;
+    columnName: string;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestOracleImportConfig {
-    query: string;
+export interface CreateTableImportRequestJdbcTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestPostgreSqlImportConfig {
-    query: string;
+export interface CreateTableImportRequestLongColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestMicrosoftAccessTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestMicrosoftSqlServerTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestOracleTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestPostgreSqlTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestSnowflakeTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestStringColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
 }
 /**
  * The import configuration for a specific connector type.
@@ -383,25 +434,64 @@ export interface CreateTableImportRequestPostgreSqlImportConfig {
  */
 export type CreateTableImportRequestTableImportConfig = ({
     type: "jdbcImportConfig";
-} & CreateTableImportRequestJdbcImportConfig) | ({
+} & CreateTableImportRequestJdbcTableImportConfig) | ({
     type: "microsoftSqlServerImportConfig";
-} & CreateTableImportRequestMicrosoftSqlServerImportConfig) | ({
+} & CreateTableImportRequestMicrosoftSqlServerTableImportConfig) | ({
     type: "postgreSqlImportConfig";
-} & CreateTableImportRequestPostgreSqlImportConfig) | ({
+} & CreateTableImportRequestPostgreSqlTableImportConfig) | ({
     type: "microsoftAccessImportConfig";
-} & CreateTableImportRequestMicrosoftAccessImportConfig) | ({
+} & CreateTableImportRequestMicrosoftAccessTableImportConfig) | ({
+    type: "snowflakeImportConfig";
+} & CreateTableImportRequestSnowflakeTableImportConfig) | ({
     type: "oracleImportConfig";
-} & CreateTableImportRequestOracleImportConfig);
-/**
-   * Direct connections enable users to connect
-to data sources accessible over the Internet without needing to set up an agent. If your Foundry stack is
-hosted on-premises, you can also connect to data sources within your on-premises network.
-This is the preferred source connection method if the data source is accessible over the Internet.
+} & CreateTableImportRequestOracleTableImportConfig);
+/**
+   * The incremental configuration for a table import enables append-style transactions from the same table without duplication of data.
+You must provide a monotonically increasing column such as a timestamp or id and an initial value for this column.
+An incremental table import will import rows where the value is greater than the largest already imported.
+You can use the '?' character to reference the incremental state value when constructing your query.
+Normally this would be used in a WHERE clause or similar filter applied in order to only sync data with an incremental column value
+larger than the previously observed maximum value stored in the incremental state.
    *
-   * Log Safety: SAFE
+   * Log Safety: UNSAFE
    */
-export interface DirectConnectionRuntime {
-    networkEgressPolicyRids: Array<NetworkEgressPolicyRid>;
+export type CreateTableImportRequestTableImportInitialIncrementalState = ({
+    type: "stringColumnInitialIncrementalState";
+} & CreateTableImportRequestStringColumnInitialIncrementalState) | ({
+    type: "dateColumnInitialIncrementalState";
+} & CreateTableImportRequestDateColumnInitialIncrementalState) | ({
+    type: "integerColumnInitialIncrementalState";
+} & CreateTableImportRequestIntegerColumnInitialIncrementalState) | ({
+    type: "timestampColumnInitialIncrementalState";
+} & CreateTableImportRequestTimestampColumnInitialIncrementalState) | ({
+    type: "longColumnInitialIncrementalState";
+} & CreateTableImportRequestLongColumnInitialIncrementalState) | ({
+    type: "decimalColumnInitialIncrementalState";
+} & CreateTableImportRequestDecimalColumnInitialIncrementalState);
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestTimestampColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * The state for an incremental table import using a column with a date type.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface DateColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: string;
+}
+/**
+ * The state for an incremental table import using a column with a decimal data type.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface DecimalColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: string;
 }
 /**
  * The domain that the connection is allowed to access.
@@ -594,13 +684,34 @@ export interface FileSizeFilter {
 export interface HeaderApiKey {
     headerName: string;
 }
+/**
+ * The state for an incremental table import using a numeric integer datatype.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface IntegerColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: number;
+}
+/**
+ * The configuration needed to connect to an external system using the JDBC protocol.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface JdbcConnectionConfiguration {
+    url: string;
+    driverClass: string;
+    jdbcProperties: Record<string, string>;
+    credentials?: BasicCredentials;
+}
 /**
  * The import configuration for a custom JDBC connection.
  *
  * Log Safety: UNSAFE
  */
-export interface JdbcImportConfig {
-    query: string;
+export interface JdbcTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * Log Safety: UNSAFE
@@ -616,21 +727,32 @@ export interface ListTableImportsResponse {
     data: Array<TableImport>;
     nextPageToken?: _Core.PageToken;
 }
+/**
+ * The state for an incremental table import using a column with a numeric long datatype.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface LongColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: string;
+}
 /**
  * The import configuration for a Microsoft Access connection.
  *
  * Log Safety: UNSAFE
  */
-export interface MicrosoftAccessImportConfig {
-    query: string;
+export interface MicrosoftAccessTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * The import configuration for a Microsoft SQL Server connection.
  *
  * Log Safety: UNSAFE
  */
-export interface MicrosoftSqlServerImportConfig {
-    query: string;
+export interface MicrosoftSqlServerTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * The Resource Identifier (RID) of a Network Egress Policy.
@@ -638,24 +760,14 @@ export interface MicrosoftSqlServerImportConfig {
  * Log Safety: SAFE
  */
 export type NetworkEgressPolicyRid = LooselyBrandedString<"NetworkEgressPolicyRid">;
-/**
-   * OpenID Connect (OIDC) is an open authentication protocol that allows
-you to authenticate to external system resources without the use of static credentials.
-   *
-   * Log Safety: UNSAFE
-   */
-export interface Oidc {
-    audience: string;
-    issuerUrl: string;
-    subject: ConnectionRid;
-}
 /**
  * The import configuration for an Oracle Database 21 connection.
  *
  * Log Safety: UNSAFE
  */
-export interface OracleImportConfig {
-    query: string;
+export interface OracleTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * Log Safety: DO_NOT_LOG
@@ -666,8 +778,9 @@ export type PlaintextValue = LooselyBrandedString<"PlaintextValue">;
  *
  * Log Safety: UNSAFE
  */
-export interface PostgreSqlImportConfig {
-    query: string;
+export interface PostgreSqlTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * Protocol to establish a connection with another system.
@@ -751,19 +864,6 @@ export type RestRequestApiKeyLocation = ({
 } & HeaderApiKey) | ({
     type: "queryParameter";
 } & QueryParameterApiKey);
-/**
-   * The runtime of a Connection, which defines the
-networking configuration and where capabilities are executed.
-   *
-   * Log Safety: UNSAFE
-   */
-export type RuntimePlatform = ({
-    type: "directConnectionRuntime";
-} & DirectConnectionRuntime) | ({
-    type: "agentProxyRuntime";
-} & AgentProxyRuntime) | ({
-    type: "agentWorkerRuntime";
-} & AgentWorkerRuntime);
 /**
  * Log Safety: UNSAFE
  */
@@ -773,7 +873,7 @@ export type S3AuthenticationMode = ({
     type: "cloudIdentity";
 } & CloudIdentity) | ({
     type: "oidc";
-} & Oidc);
+} & AwsOidcAuthentication);
 /**
    * The configuration needed to connect to an AWS S3 external system (or any other S3-like external systems that
 implement the s3a protocol).
@@ -835,6 +935,69 @@ This should be used when creating or updating additional secrets for a REST conn
 export interface SecretsWithPlaintextValues {
     secrets: Record<SecretName, PlaintextValue>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export type SnowflakeAuthenticationMode = ({
+    type: "externalOauth";
+} & SnowflakeExternalOauth) | ({
+    type: "keyPair";
+} & SnowflakeKeyPairAuthentication) | ({
+    type: "basic";
+} & BasicCredentials);
+/**
+ * The configuration needed to connect to a Snowflake database.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface SnowflakeConnectionConfiguration {
+    accountIdentifier: string;
+    database?: string;
+    role?: string;
+    schema?: string;
+    warehouse?: string;
+    authenticationMode: SnowflakeAuthenticationMode;
+    jdbcProperties: Record<string, string>;
+}
+/**
+   * Use an External OAuth security integration to connect and authenticate to Snowflake.
+See https://docs.snowflake.com/en/user-guide/oauth-ext-custom
+   *
+   * Log Safety: UNSAFE
+   */
+export interface SnowflakeExternalOauth {
+    audience: string;
+    issuerUrl: string;
+    subject: ConnectionRid;
+}
+/**
+   * Use a key-pair to connect and authenticate to Snowflake.
+See https://docs.snowflake.com/en/user-guide/key-pair-auth
+   *
+   * Log Safety: UNSAFE
+   */
+export interface SnowflakeKeyPairAuthentication {
+    user: string;
+    privateKey: EncryptedProperty;
+}
+/**
+ * The table import configuration for a Snowflake connection.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface SnowflakeTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
+}
+/**
+ * The state for an incremental table import using a column with a string data type.
+ *
+ * Log Safety: UNSAFE
+ */
+export interface StringColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: string;
+}
 /**
  * Log Safety: UNSAFE
  */
@@ -871,19 +1034,44 @@ export type TableImportAllowSchemaChanges = boolean;
  */
 export type TableImportConfig = ({
     type: "jdbcImportConfig";
-} & JdbcImportConfig) | ({
+} & JdbcTableImportConfig) | ({
     type: "microsoftSqlServerImportConfig";
-} & MicrosoftSqlServerImportConfig) | ({
+} & MicrosoftSqlServerTableImportConfig) | ({
     type: "postgreSqlImportConfig";
-} & PostgreSqlImportConfig) | ({
+} & PostgreSqlTableImportConfig) | ({
     type: "microsoftAccessImportConfig";
-} & MicrosoftAccessImportConfig) | ({
+} & MicrosoftAccessTableImportConfig) | ({
+    type: "snowflakeImportConfig";
+} & SnowflakeTableImportConfig) | ({
     type: "oracleImportConfig";
-} & OracleImportConfig);
+} & OracleTableImportConfig);
 /**
  * Log Safety: UNSAFE
  */
 export type TableImportDisplayName = LooselyBrandedString<"TableImportDisplayName">;
+/**
+   * The incremental configuration for a table import enables append-style transactions from the same table without duplication of data.
+You must provide a monotonically increasing column such as a timestamp or id and an initial value for this column.
+An incremental table import will import rows where the value is greater than the largest already imported.
+You can use the '?' character to reference the incremental state value when constructing your query.
+Normally this would be used in a WHERE clause or similar filter applied in order to only sync data with an incremental column value
+larger than the previously observed maximum value stored in the incremental state.
+   *
+   * Log Safety: UNSAFE
+   */
+export type TableImportInitialIncrementalState = ({
+    type: "stringColumnInitialIncrementalState";
+} & StringColumnInitialIncrementalState) | ({
+    type: "dateColumnInitialIncrementalState";
+} & DateColumnInitialIncrementalState) | ({
+    type: "integerColumnInitialIncrementalState";
+} & IntegerColumnInitialIncrementalState) | ({
+    type: "timestampColumnInitialIncrementalState";
+} & TimestampColumnInitialIncrementalState) | ({
+    type: "longColumnInitialIncrementalState";
+} & LongColumnInitialIncrementalState) | ({
+    type: "decimalColumnInitialIncrementalState";
+} & DecimalColumnInitialIncrementalState);
 /**
    * Import mode governs how data is read from an external system, and written into a Foundry dataset.
 SNAPSHOT: Defines a new dataset state consisting only of data from a particular import execution.
@@ -892,12 +1080,27 @@ APPEND: Purely additive and yields data from previous import executions in addit
    * Log Safety: SAFE
    */
 export type TableImportMode = "SNAPSHOT" | "APPEND";
+/**
+   * A single SQL query can be executed per sync, which should output a data table
+and avoid operations like invoking stored procedures.
+The query results are saved to the output dataset in Foundry.
+   *
+   * Log Safety: UNSAFE
+   */
+export type TableImportQuery = LooselyBrandedString<"TableImportQuery">;
 /**
  * The Resource Identifier (RID) of a TableImport (also known as a batch sync).
  *
  * Log Safety: SAFE
  */
 export type TableImportRid = LooselyBrandedString<"TableImportRid">;
+/**
+ * Log Safety: UNSAFE
+ */
+export interface TimestampColumnInitialIncrementalState {
+    columnName: string;
+    currentValue: string;
+}
 /**
  * Log Safety: DO_NOT_LOG
  */