import {z} from 'zod'

export type DestinationConnectorType = 'unstructured_blob_storage' | 'astradb' | 'chroma' | 'couchbase' | 'databricks_volumes' | 'databricks_volume_delta_tables' | 'delta_table' | 'dropbox' | 'elasticsearch' | 'kafka-cloud' | 'kdbai' | 'local' | 'milvus' | 'mongodb' | 'motherduck' | 'neo4j' | 'onedrive' | 'pinecone' | 'postgres' | 'redis' | 'qdrant-cloud' | 'sftp' | 'singlestore' | 'snowflake' | 'teradata' | 'vastdb' | 'weaviate-cloud' | 'ibm_watsonx_s3' | 's3' | 'azure' | 'gcs';

export type AstraDBConnectorConfigInput = {collection_name: string, keyspace?: (string | null) | undefined, batch_size?: number | undefined, binary_encode_vectors?: boolean | undefined, api_endpoint: string, token: string, flatten_metadata?: boolean | undefined} | {[key: string]: unknown};

export type CouchbaseDestinationConnectorConfigInput = {bucket: string, connection_string: string, scope?: (string | null) | undefined, collection?: (string | null) | undefined, batch_size: number, username: string, password: string} | {[key: string]: unknown};

export type DatabricksVolumesConnectorConfigInput = {host: string, catalog: string, schema?: string | undefined, volume: string, volume_path: string, token?: (string | null) | undefined, client_id?: (string | null) | undefined, client_secret?: (string | null) | undefined} | {[key: string]: unknown};

export type DatabricksVDTDestinationConnectorConfigInput = {server_hostname: string, http_path: string, token?: (string | null) | undefined, client_id?: (string | null) | undefined, client_secret?: (string | null) | undefined, catalog: string, database?: string | undefined, table_name?: (string | null) | undefined, schema?: string | undefined, volume: string, volume_path?: (string | null) | undefined} | {[key: string]: unknown};

export type DeltaTableConnectorConfigInput = {aws_access_key_id: string, aws_secret_access_key: string, aws_region: string, table_uri: string} | {[key: string]: unknown};

export type ElasticsearchConnectorConfigInput = {hosts: Array<string>, index_name: string, es_api_key: string} | {[key: string]: unknown};

export type KafkaCloudDestinationConnectorConfigInput = {bootstrap_servers: string, port?: number | undefined, group_id?: (string | null) | undefined, topic: string, kafka_api_key: string, secret: string, batch_size?: number | undefined} | {[key: string]: unknown};

export type MilvusDestinationConnectorConfigInput = {uri: string, user?: (string | null) | undefined, token?: (string | null) | undefined, password?: (string | null) | undefined, db_name?: (string | null) | undefined, collection_name: string, record_id_key: string, flatten_metadata?: boolean | undefined, fields_to_include?: (Array<string> | null) | undefined} | {[key: string]: unknown};

export type MongoDBConnectorConfigInput = {database: string, collection: string, uri: string} | {[key: string]: unknown};

export type Neo4jDestinationConnectorConfigInput = {uri: string, database: string, username: string, password: string, batch_size?: number | undefined} | {[key: string]: unknown};

export type OneDriveDestinationConnectorConfigInput = {client_id?: (string | null) | undefined, user_pname: string, tenant: string, authority_url?: string | undefined, client_cred?: (string | null) | undefined, oauth_token?: (string | null) | undefined, refresh_token?: (string | null) | undefined, remote_url: string} | {[key: string]: unknown};

export type PineconeDestinationConnectorConfigInput = {index_name: string, api_key: string, namespace: string, batch_size?: number | undefined} | {[key: string]: unknown};

export type PostgresDestinationConnectorConfigInput = {host: string, database: string, port: number, username: string, password: string, table_name: string, batch_size: number} | {[key: string]: unknown};

export type RedisDestinationConnectorConfigInput = {host: string, port?: number | undefined, username?: (string | null) | undefined, password?: (string | null) | undefined, uri?: (string | null) | undefined, database?: number | undefined, ssl?: boolean | undefined, batch_size?: number | undefined} | {[key: string]: unknown};

export type QdrantCloudDestinationConnectorConfigInput = {url: string, api_key: string, collection_name: string, batch_size?: number | undefined} | {[key: string]: unknown};

export type SnowflakeDestinationConnectorConfigInput = {account: string, role: string, user: string, password: string, host: string, port?: number | undefined, database: string, schema: string, table_name?: string | undefined, batch_size?: number | undefined, record_id_key?: (string | null) | undefined} | {[key: string]: unknown};

export type TeradataDestinationConnectorConfigInput = {host: string, user?: (string | null) | undefined, password?: (string | null) | undefined, database?: (string | null) | undefined, dbs_port?: number | undefined, use_signed_in_user?: (boolean | null) | undefined, table_name?: string | undefined, batch_size?: number | undefined, record_id_key?: (string | null) | undefined, metadata_as_json?: boolean | undefined, skip_empty_text_elements?: boolean | undefined} | {[key: string]: unknown};

export type WeaviateDestinationConnectorConfigInput = {cluster_url: string, api_key: string, collection?: (string | null) | undefined} | {[key: string]: unknown};

export type IBMWatsonxS3DestinationConnectorConfigInput = {iam_api_key: string, access_key_id: string, secret_access_key: string, iceberg_endpoint: string, object_storage_endpoint: string, object_storage_region: string, catalog: string, account_id?: (string | null) | undefined, max_retries_connection?: number | undefined, namespace: string, table: string, max_retries?: number | undefined, record_id_key?: string | undefined} | {[key: string]: unknown};

export type S3DestinationConnectorConfigInput = {remote_url: string, anonymous?: boolean | undefined, ambient_credentials?: boolean | undefined, key?: (string | null) | undefined, secret?: (string | null) | undefined, token?: (string | null) | undefined, endpoint_url?: (string | null) | undefined, role_arn?: (string | null) | undefined, external_id?: (string | null) | undefined} | {[key: string]: unknown};

export type AzureDestinationConnectorConfigInput = {remote_url: string, account_name?: (string | null) | undefined, account_key?: (string | null) | undefined, connection_string?: (string | null) | undefined, sas_token?: (string | null) | undefined} | {[key: string]: unknown};

export type CreateDestinationConnector = {name: string, type: DestinationConnectorType | string, config: AstraDBConnectorConfigInput | CouchbaseDestinationConnectorConfigInput | DatabricksVolumesConnectorConfigInput | DatabricksVDTDestinationConnectorConfigInput | DeltaTableConnectorConfigInput | ElasticsearchConnectorConfigInput | KafkaCloudDestinationConnectorConfigInput | MilvusDestinationConnectorConfigInput | MongoDBConnectorConfigInput | Neo4jDestinationConnectorConfigInput | OneDriveDestinationConnectorConfigInput | PineconeDestinationConnectorConfigInput | PostgresDestinationConnectorConfigInput | RedisDestinationConnectorConfigInput | QdrantCloudDestinationConnectorConfigInput | SnowflakeDestinationConnectorConfigInput | TeradataDestinationConnectorConfigInput | WeaviateDestinationConnectorConfigInput | IBMWatsonxS3DestinationConnectorConfigInput | S3DestinationConnectorConfigInput | AzureDestinationConnectorConfigInput | {[key: string]: unknown}, key?: (string | null) | undefined};

export type CreateApiApiV1DestinationsArgs = {'unstructured-api-key'?: (string | null) | undefined, body: CreateDestinationConnector};

export type CreateApiApiV1DestinationsOptions = {baseUrl: string, fetch?: typeof fetch | undefined};

export const destinationConnectorType = z.enum(["unstructured_blob_storage", "astradb", "chroma", "couchbase", "databricks_volumes", "databricks_volume_delta_tables", "delta_table", "dropbox", "elasticsearch", "kafka-cloud", "kdbai", "local", "milvus", "mongodb", "motherduck", "neo4j", "onedrive", "pinecone", "postgres", "redis", "qdrant-cloud", "sftp", "singlestore", "snowflake", "teradata", "vastdb", "weaviate-cloud", "ibm_watsonx_s3", "s3", "azure", "gcs"]);

export const astraDBConnectorConfig = z.object({collection_name: z.string(), keyspace: z.string().nullable().optional(), batch_size: z.number().int(), binary_encode_vectors: z.boolean().optional(), api_endpoint: z.string(), token: z.string()}).and(z.record(z.string(), z.unknown()));

export const couchbaseDestinationConnectorConfig = z.object({bucket: z.string(), connection_string: z.string(), scope: z.string().nullable().optional(), collection: z.string().nullable().optional(), batch_size: z.number().int(), username: z.string(), password: z.string()}).and(z.record(z.string(), z.unknown()));

export const databricksVolumesConnectorConfig = z.object({host: z.string(), catalog: z.string(), schema: z.string().optional(), volume: z.string(), volume_path: z.string(), token: z.string().nullable().optional(), client_id: z.string().nullable().optional(), client_secret: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const databricksVDTDestinationConnectorConfig = z.object({server_hostname: z.string(), http_path: z.string(), token: z.string().nullable().optional(), client_id: z.string().nullable().optional(), client_secret: z.string().nullable().optional(), catalog: z.string(), database: z.string().optional(), table_name: z.string().nullable().optional(), schema: z.string().optional(), volume: z.string(), volume_path: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const deltaTableConnectorConfig = z.object({aws_access_key_id: z.string(), aws_secret_access_key: z.string(), aws_region: z.string(), table_uri: z.string()}).and(z.record(z.string(), z.unknown()));

export const elasticsearchConnectorConfig = z.object({hosts: z.array(z.string()), index_name: z.string(), es_api_key: z.string()}).and(z.record(z.string(), z.unknown()));

export const kafkaCloudDestinationConnectorConfig = z.object({bootstrap_servers: z.string(), port: z.number().int(), group_id: z.string().nullable().optional(), topic: z.string(), kafka_api_key: z.string(), secret: z.string(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const milvusDestinationConnectorConfig = z.object({uri: z.string(), user: z.string().nullable().optional(), token: z.string().nullable().optional(), password: z.string().nullable().optional(), db_name: z.string().nullable().optional(), collection_name: z.string(), record_id_key: z.string()}).and(z.record(z.string(), z.unknown()));

export const mongoDBConnectorConfig = z.object({database: z.string(), collection: z.string(), uri: z.string()}).and(z.record(z.string(), z.unknown()));

export const neo4jDestinationConnectorConfig = z.object({uri: z.string(), database: z.string(), username: z.string(), password: z.string(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const oneDriveDestinationConnectorConfig = z.object({client_id: z.string().nullable().optional(), user_pname: z.string(), tenant: z.string(), authority_url: z.string().optional(), client_cred: z.string().nullable().optional(), oauth_token: z.string().nullable().optional(), refresh_token: z.string().nullable().optional(), remote_url: z.string()}).and(z.record(z.string(), z.unknown()));

export const pineconeDestinationConnectorConfig = z.object({index_name: z.string(), api_key: z.string(), namespace: z.string(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const postgresDestinationConnectorConfig = z.object({host: z.string(), database: z.string(), port: z.number().int(), username: z.string(), password: z.string(), table_name: z.string(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const redisDestinationConnectorConfig = z.object({host: z.string(), port: z.number().int(), username: z.string().nullable().optional(), password: z.string().nullable().optional(), uri: z.string().nullable().optional(), database: z.number().int(), ssl: z.boolean(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const qdrantCloudDestinationConnectorConfig = z.object({url: z.string(), api_key: z.string(), collection_name: z.string(), batch_size: z.number().int()}).and(z.record(z.string(), z.unknown()));

export const snowflakeDestinationConnectorConfig = z.object({account: z.string(), role: z.string(), user: z.string(), password: z.string(), host: z.string(), port: z.number().int().gte(1).optional(), database: z.string(), schema: z.string(), table_name: z.string().optional(), batch_size: z.number().int().gte(1).optional(), record_id_key: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const teradataDestinationConnectorConfig = z.object({host: z.string(), user: z.string().nullable().optional(), password: z.string().nullable().optional(), database: z.string().nullable().optional(), dbs_port: z.number().int().gte(1).optional(), use_signed_in_user: z.boolean().nullable().optional(), table_name: z.string().optional(), batch_size: z.number().int().gte(1).optional(), record_id_key: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const weaviateDestinationConnectorConfig = z.object({cluster_url: z.string(), api_key: z.string(), collection: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const iBMWatsonxS3DestinationConnectorConfig = z.object({iam_api_key: z.string(), access_key_id: z.string(), secret_access_key: z.string(), iceberg_endpoint: z.string(), object_storage_endpoint: z.string(), object_storage_region: z.string(), catalog: z.string(), account_id: z.string().nullable().optional(), max_retries_connection: z.number().int(), namespace: z.string(), table: z.string(), max_retries: z.number().int(), record_id_key: z.string()}).and(z.record(z.string(), z.unknown()));

export const s3DestinationConnectorConfig = z.object({remote_url: z.string(), anonymous: z.boolean(), ambient_credentials: z.boolean().nullable().optional(), key: z.string().nullable().optional(), secret: z.string().nullable().optional(), token: z.string().nullable().optional(), endpoint_url: z.string().nullable().optional(), role_arn: z.string().nullable().optional(), external_id: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const azureDestinationConnectorConfig = z.object({remote_url: z.string(), account_name: z.string().nullable().optional(), account_key: z.string().nullable().optional(), connection_string: z.string().nullable().optional(), sas_token: z.string().nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const destinationConnectorInformation = z.object({id: z.string(), name: z.string(), type: z.union([destinationConnectorType, z.string()]), config: z.union([astraDBConnectorConfig, couchbaseDestinationConnectorConfig, databricksVolumesConnectorConfig, databricksVDTDestinationConnectorConfig, deltaTableConnectorConfig, elasticsearchConnectorConfig, kafkaCloudDestinationConnectorConfig, milvusDestinationConnectorConfig, mongoDBConnectorConfig, neo4jDestinationConnectorConfig, oneDriveDestinationConnectorConfig, pineconeDestinationConnectorConfig, postgresDestinationConnectorConfig, redisDestinationConnectorConfig, qdrantCloudDestinationConnectorConfig, snowflakeDestinationConnectorConfig, teradataDestinationConnectorConfig, weaviateDestinationConnectorConfig, iBMWatsonxS3DestinationConnectorConfig, s3DestinationConnectorConfig, azureDestinationConnectorConfig, z.record(z.string(), z.unknown())]), created_at: z.string(), updated_at: z.string().nullable().optional(), key: z.string().nullable().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Create destination connector
 * 
 * POST /api/v1/destinations/
 */
export const createApiApiV1Destinations = async (args: CreateApiApiV1DestinationsArgs, options: CreateApiApiV1DestinationsOptions) => {
const {baseUrl, fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

if (args['unstructured-api-key'] != null) headers.set("unstructured-api-key", String(args['unstructured-api-key']))

const url = `${baseUrl.replace(/\/+$/, '')}/api/v1/destinations/${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(destinationConnectorInformation, await res.json())
};