@osdk/foundry.connectivity 2.17.0 → 2.19.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @osdk/foundry.connectivity
 
+## 2.19.0
+
+### Minor Changes
+
+- 539c731: Regenerate Platform SDKs
+
+### Patch Changes
+
+- Updated dependencies [539c731]
+  - @osdk/foundry.orchestration@2.19.0
+  - @osdk/foundry.filesystem@2.19.0
+  - @osdk/foundry.datasets@2.19.0
+  - @osdk/foundry.core@2.19.0
+
+## 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

package/build/browser/_components.d.ts

@@ -103,6 +103,8 @@ export type ConnectionConfiguration = ({
 } & S3ConnectionConfiguration) | ({
     type: "rest";
 } & RestConnectionConfiguration) | ({
+    type: "snowflake";
+} & SnowflakeConnectionConfiguration) | ({
     type: "jdbc";
 } & JdbcConnectionConfiguration);
 /**
@@ -171,6 +173,8 @@ export type CreateConnectionRequestConnectionConfiguration = ({
 } & CreateConnectionRequestS3ConnectionConfiguration) | ({
     type: "rest";
 } & CreateConnectionRequestRestConnectionConfiguration) | ({
+    type: "snowflake";
+} & CreateConnectionRequestSnowflakeConnectionConfiguration) | ({
     type: "jdbc";
 } & CreateConnectionRequestJdbcConnectionConfiguration);
 /**
@@ -280,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
  */
@@ -315,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 CreateTableImportRequestDecimalColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestIntegerColumnInitialIncrementalState {
+    currentValue: number;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface CreateTableImportRequestJdbcTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestMicrosoftAccessImportConfig {
-    query: string;
+export interface CreateTableImportRequestLongColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestMicrosoftSqlServerImportConfig {
-    query: string;
+export interface CreateTableImportRequestMicrosoftAccessTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestOracleImportConfig {
-    query: string;
+export interface CreateTableImportRequestMicrosoftSqlServerTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
 }
 /**
  * Log Safety: UNSAFE
  */
-export interface CreateTableImportRequestPostgreSqlImportConfig {
-    query: string;
+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.
@@ -349,15 +434,65 @@ 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);
+} & 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: UNSAFE
+   */
+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.
  *
@@ -549,6 +684,15 @@ 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.
  *
@@ -565,8 +709,9 @@ export interface JdbcConnectionConfiguration {
  *
  * Log Safety: UNSAFE
  */
-export interface JdbcImportConfig {
-    query: string;
+export interface JdbcTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * Log Safety: UNSAFE
@@ -582,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.
@@ -609,8 +765,9 @@ export type NetworkEgressPolicyRid = LooselyBrandedString<"NetworkEgressPolicyRi
  *
  * Log Safety: UNSAFE
  */
-export interface OracleImportConfig {
-    query: string;
+export interface OracleTableImportConfig {
+    query: TableImportQuery;
+    initialIncrementalState?: TableImportInitialIncrementalState;
 }
 /**
  * Log Safety: DO_NOT_LOG
@@ -621,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.
@@ -653,6 +811,142 @@ export interface ReplaceFileImportRequest {
     subfolder?: string;
     fileImportFilters: Array<FileImportFilter>;
 }
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequest {
+    datasetRid: _Datasets.DatasetRid;
+    importMode: TableImportMode;
+    displayName: TableImportDisplayName;
+    allowSchemaChanges?: TableImportAllowSchemaChanges;
+    branchName?: _Datasets.BranchName;
+    config: ReplaceTableImportRequestTableImportConfig;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestDateColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestDecimalColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestIntegerColumnInitialIncrementalState {
+    currentValue: number;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestJdbcTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestLongColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestMicrosoftAccessTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestMicrosoftSqlServerTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestOracleTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestPostgreSqlTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestSnowflakeTableImportConfig {
+    initialIncrementalState?: TableImportInitialIncrementalState;
+    query: TableImportQuery;
+}
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestStringColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
+/**
+ * The import configuration for a specific connector type.
+ *
+ * Log Safety: UNSAFE
+ */
+export type ReplaceTableImportRequestTableImportConfig = ({
+    type: "jdbcImportConfig";
+} & ReplaceTableImportRequestJdbcTableImportConfig) | ({
+    type: "microsoftSqlServerImportConfig";
+} & ReplaceTableImportRequestMicrosoftSqlServerTableImportConfig) | ({
+    type: "postgreSqlImportConfig";
+} & ReplaceTableImportRequestPostgreSqlTableImportConfig) | ({
+    type: "microsoftAccessImportConfig";
+} & ReplaceTableImportRequestMicrosoftAccessTableImportConfig) | ({
+    type: "snowflakeImportConfig";
+} & ReplaceTableImportRequestSnowflakeTableImportConfig) | ({
+    type: "oracleImportConfig";
+} & ReplaceTableImportRequestOracleTableImportConfig);
+/**
+   * 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 ReplaceTableImportRequestTableImportInitialIncrementalState = ({
+    type: "stringColumnInitialIncrementalState";
+} & ReplaceTableImportRequestStringColumnInitialIncrementalState) | ({
+    type: "dateColumnInitialIncrementalState";
+} & ReplaceTableImportRequestDateColumnInitialIncrementalState) | ({
+    type: "integerColumnInitialIncrementalState";
+} & ReplaceTableImportRequestIntegerColumnInitialIncrementalState) | ({
+    type: "timestampColumnInitialIncrementalState";
+} & ReplaceTableImportRequestTimestampColumnInitialIncrementalState) | ({
+    type: "longColumnInitialIncrementalState";
+} & ReplaceTableImportRequestLongColumnInitialIncrementalState) | ({
+    type: "decimalColumnInitialIncrementalState";
+} & ReplaceTableImportRequestDecimalColumnInitialIncrementalState);
+/**
+ * Log Safety: UNSAFE
+ */
+export interface ReplaceTableImportRequestTimestampColumnInitialIncrementalState {
+    currentValue: string;
+    columnName: string;
+}
 /**
  * The method of authentication for connecting to an external REST system.
  *
@@ -777,6 +1071,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
  */
@@ -813,19 +1170,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.
@@ -834,12 +1216,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
  */