import {z} from 'zod'

export type GetApiApiV1ProjectsProjectUuidArgs = {projectUuid: string};

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

export const recordStringString = z.object({});

export const timeFrames = z.enum(["RAW", "YEAR", "QUARTER", "MONTH", "WEEK", "DAY", "HOUR", "MINUTE", "SECOND", "MILLISECOND", "DAY_OF_WEEK_INDEX", "DAY_OF_MONTH_NUM", "DAY_OF_YEAR_NUM", "WEEK_NUM", "MONTH_NUM", "QUARTER_NUM", "YEAR_NUM", "DAY_OF_WEEK_NAME", "MONTH_NAME", "QUARTER_NAME", "HOUR_OF_DAY_NUM", "MINUTE_OF_HOUR_NUM"]);

export const projectDefaults = z.object({granularity_labels: recordStringString.optional(), additional_time_intervals: z.object({timestamp: z.array(z.union([timeFrames, z.string()])).optional(), date: z.array(z.union([timeFrames, z.string()])).optional()}).optional(), column_totals: z.boolean().optional(), case_sensitive: z.boolean().optional()});

export const supportedDbtVersions = z.enum(["v1.4", "v1.5", "v1.6", "v1.7", "v1.8", "v1.9", "v1.10", "v1.11", "v1.12"]);

export const dbtVersionOptionLatest = z.literal("latest");

export const dbtVersionOption = z.union([supportedDbtVersions, dbtVersionOptionLatest]);

export const warehouseTypesSNOWFLAKE = z.literal("snowflake");

export const snowflakeAuthenticationType = z.enum(["password", "private_key", "sso", "external_browser", "oauth_authorization_code", "none"]);

export const weekDay = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(5), z.literal(6)]);

export const pickCreateSnowflakeCredentialsExcludeKeyofCreateSnowflakeCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesSNOWFLAKE, account: z.string(), requireUserCredentials: z.boolean().optional(), authenticationType: snowflakeAuthenticationType.optional(), role: z.string().optional(), database: z.string(), warehouse: z.string(), schema: z.string(), threads: z.number().optional(), clientSessionKeepAlive: z.boolean().optional(), queryTag: z.string().optional(), accessUrl: z.string().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), quotedIdentifiersIgnoreCase: z.boolean().optional(), disableTimestampConversion: z.boolean().optional(), timeoutSeconds: z.number().optional(), override: z.boolean().optional(), organizationWarehouseCredentialsUuid: z.string().optional()});

export const snowflakeCredentials = pickCreateSnowflakeCredentialsExcludeKeyofCreateSnowflakeCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesREDSHIFT = z.literal("redshift");

export const redshiftAuthenticationType = z.enum(["password", "iam", "iam_browser"]);

export const pickCreateRedshiftCredentialsExcludeKeyofCreateRedshiftCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesREDSHIFT, requireUserCredentials: z.boolean().optional(), authenticationType: redshiftAuthenticationType.optional(), schema: z.string(), threads: z.number().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), timeoutSeconds: z.number().optional(), useSshTunnel: z.boolean().optional(), sshTunnelHost: z.string().optional(), sshTunnelPort: z.number().optional(), sshTunnelUser: z.string().optional(), sshTunnelPublicKey: z.string().optional(), host: z.string(), port: z.number(), dbname: z.string(), keepalivesIdle: z.number().optional(), sslmode: z.string().optional(), ra3Node: z.boolean().optional(), region: z.string().optional(), isServerless: z.boolean().optional(), clusterIdentifier: z.string().optional(), workgroupName: z.string().optional(), autoCreate: z.boolean().optional(), dbGroups: z.array(z.string()).optional(), assumeRoleArn: z.string().optional(), assumeRoleExternalId: z.string().optional(), awsSsoStartUrl: z.string().optional(), awsSsoRegion: z.string().optional(), awsSsoAccountId: z.string().optional(), awsSsoRoleName: z.string().optional()});

export const redshiftCredentials = pickCreateRedshiftCredentialsExcludeKeyofCreateRedshiftCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesPOSTGRES = z.literal("postgres");

export const pickCreatePostgresCredentialsExcludeKeyofCreatePostgresCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesPOSTGRES, requireUserCredentials: z.boolean().optional(), role: z.string().optional(), schema: z.string(), threads: z.number().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), timeoutSeconds: z.number().optional(), useSshTunnel: z.boolean().optional(), sshTunnelHost: z.string().optional(), sshTunnelPort: z.number().optional(), sshTunnelUser: z.string().optional(), sshTunnelPublicKey: z.string().optional(), host: z.string(), port: z.number(), dbname: z.string(), keepalivesIdle: z.number().optional(), sslmode: z.string().optional(), sslcertFileName: z.string().optional(), sslkeyFileName: z.string().optional(), sslrootcertFileName: z.string().optional(), searchPath: z.string().optional()});

export const postgresCredentials = pickCreatePostgresCredentialsExcludeKeyofCreatePostgresCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesBIGQUERY = z.literal("bigquery");

export const bigqueryAuthenticationType = z.enum(["sso", "private_key", "adc"]);

export const pickCreateBigqueryCredentialsExcludeKeyofCreateBigqueryCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesBIGQUERY, requireUserCredentials: z.boolean().optional(), authenticationType: bigqueryAuthenticationType.optional(), threads: z.number().optional(), accessUrl: z.string().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), timeoutSeconds: z.number().optional(), project: z.string(), dataset: z.string(), priority: z.enum(["interactive", "batch"]).optional(), retries: z.number().optional(), location: z.string().optional(), maximumBytesBilled: z.number().optional(), executionProject: z.string().optional()});

export const bigqueryCredentials = pickCreateBigqueryCredentialsExcludeKeyofCreateBigqueryCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesDATABRICKS = z.literal("databricks");

export const databricksAuthenticationType = z.enum(["personal_access_token", "oauth_m2m", "oauth_u2m"]);

export const pickCreateDatabricksCredentialsExcludeKeyofCreateDatabricksCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesDATABRICKS, catalog: z.string().optional(), requireUserCredentials: z.boolean().optional(), authenticationType: databricksAuthenticationType.optional(), database: z.string(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), serverHostName: z.string(), httpPath: z.string(), compute: z.array(z.object({httpPath: z.string(), name: z.string()})).optional()});

export const databricksCredentials = pickCreateDatabricksCredentialsExcludeKeyofCreateDatabricksCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesTRINO = z.literal("trino");

export const pickCreateTrinoCredentialsExcludeKeyofCreateTrinoCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesTRINO, requireUserCredentials: z.boolean().optional(), schema: z.string(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), host: z.string(), port: z.number(), dbname: z.string(), http_scheme: z.string(), source: z.string().optional()});

export const trinoCredentials = pickCreateTrinoCredentialsExcludeKeyofCreateTrinoCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesCLICKHOUSE = z.literal("clickhouse");

export const pickCreateClickhouseCredentialsExcludeKeyofCreateClickhouseCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesCLICKHOUSE, requireUserCredentials: z.boolean().optional(), schema: z.string(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), timeoutSeconds: z.number().optional(), host: z.string(), port: z.number(), secure: z.boolean().optional()});

export const clickhouseCredentials = pickCreateClickhouseCredentialsExcludeKeyofCreateClickhouseCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesATHENA = z.literal("athena");

export const athenaAuthenticationType = z.enum(["access_key", "iam_role"]);

export const pickCreateAthenaCredentialsExcludeKeyofCreateAthenaCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesATHENA, requireUserCredentials: z.boolean().optional(), authenticationType: athenaAuthenticationType.optional(), database: z.string(), schema: z.string(), threads: z.number().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), region: z.string(), assumeRoleArn: z.string().optional(), assumeRoleExternalId: z.string().optional(), s3StagingDir: z.string(), s3DataDir: z.string().optional(), workGroup: z.string().optional(), numRetries: z.number().optional()});

export const athenaCredentials = pickCreateAthenaCredentialsExcludeKeyofCreateAthenaCredentialsSensitiveCredentialsFieldNames;

export const warehouseTypesDUCKDB = z.literal("duckdb");

export const duckdbConnectionTypeMOTHERDUCK = z.literal("motherduck");

export const pickCreateDuckdbMotherduckCredentialsExcludeKeyofCreateDuckdbMotherduckCredentialsSensitiveCredentialsFieldNames = z.object({type: warehouseTypesDUCKDB, requireUserCredentials: z.boolean().optional(), database: z.string(), schema: z.string(), threads: z.number().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), connectionType: duckdbConnectionTypeMOTHERDUCK});

export const duckdbMotherduckCredentials = pickCreateDuckdbMotherduckCredentialsExcludeKeyofCreateDuckdbMotherduckCredentialsSensitiveCredentialsFieldNames;

export const duckdbConnectionTypeDUCKLAKE = z.literal("ducklake");

export const ducklakeDataPathTypeS3 = z.literal("s3");

export const pickCreateDucklakeDataPathS3ExcludeKeyofCreateDucklakeDataPathS3AccessKeyIdOrSecretAccessKey = z.object({type: ducklakeDataPathTypeS3, url: z.string(), region: z.string().optional(), endpoint: z.string().optional(), forcePathStyle: z.boolean().optional(), useSsl: z.boolean().optional()});

export const ducklakeDataPathS3 = pickCreateDucklakeDataPathS3ExcludeKeyofCreateDucklakeDataPathS3AccessKeyIdOrSecretAccessKey;

export const ducklakeDataPathTypeGCS = z.literal("gcs");

export const pickCreateDucklakeDataPathGcsExcludeKeyofCreateDucklakeDataPathGcsHmacKeyIdOrHmacSecret = z.object({type: ducklakeDataPathTypeGCS, url: z.string()});

export const ducklakeDataPathGcs = pickCreateDucklakeDataPathGcsExcludeKeyofCreateDucklakeDataPathGcsHmacKeyIdOrHmacSecret;

export const ducklakeDataPathTypeAZURE = z.literal("azure");

export const pickCreateDucklakeDataPathAzureExcludeKeyofCreateDucklakeDataPathAzureConnectionStringOrAccountKey = z.object({type: ducklakeDataPathTypeAZURE, url: z.string(), accountName: z.string().optional()});

export const ducklakeDataPathAzure = pickCreateDucklakeDataPathAzureExcludeKeyofCreateDucklakeDataPathAzureConnectionStringOrAccountKey;

export const ducklakeDataPathTypeLOCAL = z.literal("local");

export const ducklakeDataPathLocal = z.object({path: z.string(), type: ducklakeDataPathTypeLOCAL});

export const ducklakeDataPath = z.union([ducklakeDataPathS3, ducklakeDataPathGcs, ducklakeDataPathAzure, ducklakeDataPathLocal]);

export const ducklakeCatalogTypePOSTGRES = z.literal("postgres");

export const pickCreateDucklakeCatalogPostgresExcludeKeyofCreateDucklakeCatalogPostgresUserOrPassword = z.object({type: ducklakeCatalogTypePOSTGRES, database: z.string(), host: z.string(), port: z.number()});

export const ducklakeCatalogPostgres = pickCreateDucklakeCatalogPostgresExcludeKeyofCreateDucklakeCatalogPostgresUserOrPassword;

export const ducklakeCatalogTypeSQLITE = z.literal("sqlite");

export const ducklakeCatalogSqlite = z.object({path: z.string(), type: ducklakeCatalogTypeSQLITE});

export const ducklakeCatalogTypeDUCKDB = z.literal("duckdb");

export const ducklakeCatalogDuckdb = z.object({path: z.string(), type: ducklakeCatalogTypeDUCKDB});

export const ducklakeCatalog = z.union([ducklakeCatalogPostgres, ducklakeCatalogSqlite, ducklakeCatalogDuckdb]);

export const duckdbDucklakeCredentials = z.object({type: warehouseTypesDUCKDB, requireUserCredentials: z.boolean().optional(), schema: z.string(), threads: z.number().optional(), startOfWeek: weekDay.nullable().optional(), dataTimezone: z.string().optional(), connectionType: duckdbConnectionTypeDUCKLAKE, catalogAlias: z.string().optional(), dataPath: ducklakeDataPath, catalog: ducklakeCatalog});

export const duckdbConnectionTypeEMBEDDED = z.literal("embedded");

export const duckdbEmbeddedCredentials = z.object({schema: z.string().optional(), startOfWeek: z.number().optional(), dataTimezone: z.string().optional(), requireUserCredentials: z.boolean().optional(), dataset: z.string(), connectionType: duckdbConnectionTypeEMBEDDED, type: warehouseTypesDUCKDB});

export const duckdbCredentials = z.union([duckdbMotherduckCredentials, duckdbDucklakeCredentials, duckdbEmbeddedCredentials]);

export const warehouseCredentials = z.union([snowflakeCredentials, redshiftCredentials, postgresCredentials, bigqueryCredentials, databricksCredentials, trinoCredentials, clickhouseCredentials, athenaCredentials, duckdbCredentials]);

export const dbtProjectTypeDBT = z.literal("dbt");

export const dbtProjectEnvironmentVariable = z.object({value: z.string(), key: z.string()});

export const dbtLocalProjectConfig = z.object({type: dbtProjectTypeDBT, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), profiles_dir: z.string().optional(), project_dir: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeDBTCLOUDIDE = z.literal("dbt_cloud_ide");

export const dbtCloudIDEProjectConfig = z.object({type: dbtProjectTypeDBTCLOUDIDE, api_key: z.string(), environment_id: z.string(), discovery_api_endpoint: z.string().optional(), tags: z.array(z.string()).optional(), webhook_hmac_secret: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeGITHUB = z.literal("github");

export const dbtGithubProjectConfig = z.object({type: dbtProjectTypeGITHUB, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), authorization_method: z.enum(["personal_access_token", "installation_id"]), personal_access_token: z.string().optional(), installation_id: z.string().optional(), repository: z.string(), branch: z.string(), project_sub_path: z.string(), host_domain: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeBITBUCKET = z.literal("bitbucket");

export const dbtBitBucketProjectConfig = z.object({type: dbtProjectTypeBITBUCKET, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), username: z.string(), personal_access_token: z.string(), repository: z.string(), branch: z.string(), project_sub_path: z.string(), host_domain: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeGITLAB = z.literal("gitlab");

export const dbtGitlabProjectConfig = z.object({type: dbtProjectTypeGITLAB, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), personal_access_token: z.string(), repository: z.string(), branch: z.string(), project_sub_path: z.string(), host_domain: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeAZUREDEVOPS = z.literal("azure_devops");

export const dbtAzureDevOpsProjectConfig = z.object({type: dbtProjectTypeAZUREDEVOPS, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), personal_access_token: z.string(), organization: z.string(), project: z.string(), repository: z.string(), branch: z.string(), project_sub_path: z.string()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeNONE = z.literal("none");

export const dbtNoneProjectConfig = z.object({type: dbtProjectTypeNONE, target: z.string().optional(), environment: z.array(dbtProjectEnvironmentVariable).optional(), selector: z.string().optional(), hideRefreshButton: z.boolean().optional()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectTypeMANIFEST = z.literal("manifest");

export const dbtManifestProjectConfig = z.object({type: dbtProjectTypeMANIFEST, manifest: z.string(), hideRefreshButton: z.boolean()}).and(z.record(z.string(), z.unknown()));

export const dbtProjectConfig = z.union([dbtLocalProjectConfig, dbtCloudIDEProjectConfig, dbtGithubProjectConfig, dbtBitBucketProjectConfig, dbtGitlabProjectConfig, dbtAzureDevOpsProjectConfig, dbtNoneProjectConfig, dbtManifestProjectConfig]);

export const projectType = z.enum(["DEFAULT", "PREVIEW"]);

export const project = z.object({provisioningSource: z.string().nullable().optional(), expiresAt: z.string().nullable(), colorPaletteUuid: z.string().nullable(), projectDefaults: projectDefaults.optional(), hasDefaultUserSpaces: z.boolean(), organizationWarehouseCredentialsUuid: z.string().optional(), createdByUserUuid: z.string().nullable(), schedulerFailureContactOverride: z.string().nullable(), schedulerFailureIncludeContact: z.boolean(), schedulerFailureNotifyRecipients: z.boolean(), useProjectTimezoneInFilters: z.boolean(), queryTimezone: z.string().nullable(), schedulerTimezone: z.string(), dbtVersion: dbtVersionOption, upstreamProjectUuid: z.string().optional(), pinnedListUuid: z.string().optional(), warehouseConnection: warehouseCredentials.optional(), dbtConnection: dbtProjectConfig, type: projectType, name: z.string(), projectUuid: z.string(), organizationUuid: z.string()});

export const apiProjectResponse = z.object({results: project, status: z.literal("ok")});

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
};

/**
 * Get project
 * 
 * GET /api/v1/projects/{projectUuid}
 */
export const getApiApiV1ProjectsProjectUuid = async (args: GetApiApiV1ProjectsProjectUuidArgs, options: GetApiApiV1ProjectsProjectUuidOptions) => {
const {baseUrl, fetch: fetchFn = fetch} = options ?? {}

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

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

const res = await fetchFn(url, {method: "GET", headers})

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

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