@explo-tech/fido-api 2.12.10 → 3.0.0-jordan-testing

package/index.ts

@@ -1,180 +1,2804 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export { ApiError } from './core/ApiError';
-export { CancelablePromise, CancelError } from './core/CancelablePromise';
-export { OpenAPI } from './core/OpenAPI';
-export type { OpenAPIConfig } from './core/OpenAPI';
+import { makeApi, Zodios, type ZodiosOptions } from "@zodios/core";
+import { z } from "zod";
 
-export type { AggregateProperty } from './models/AggregateProperty';
-export { Aggregation } from './models/Aggregation';
-export type { AggregationOption } from './models/AggregationOption';
-export type { And } from './models/And';
-export type { And1 } from './models/And1';
-export type { BigQuery } from './models/BigQuery';
-export type { BigQueryAuthentication } from './models/BigQueryAuthentication';
-export type { BooleanPropertyValue } from './models/BooleanPropertyValue';
-export type { Branch } from './models/Branch';
-export type { BranchResponse } from './models/BranchResponse';
-export type { BranchResponseMetadata } from './models/BranchResponseMetadata';
-export type { CacheTelemetry } from './models/CacheTelemetry';
-export { CalendarInterval } from './models/CalendarInterval';
-export type { CalendarIntervalGrouping } from './models/CalendarIntervalGrouping';
-export type { Clickhouse } from './models/Clickhouse';
-export { ClickhouseConnectionType } from './models/ClickhouseConnectionType';
-export type { ClientError } from './models/ClientError';
-export type { ColumnFormat } from './models/ColumnFormat';
-export type { Commit } from './models/Commit';
-export type { CommitResponse } from './models/CommitResponse';
-export type { Computation } from './models/Computation';
-export type { ComputedView } from './models/ComputedView';
-export type { CreateCommitRequest } from './models/CreateCommitRequest';
-export type { CreateCommitResponse } from './models/CreateCommitResponse';
-export type { CreateViewChange } from './models/CreateViewChange';
-export type { CreateViewDiff } from './models/CreateViewDiff';
-export type { DataPage } from './models/DataPage';
-export type { DataRecord } from './models/DataRecord';
-export type { DataRequestParameters } from './models/DataRequestParameters';
-export type { DataResponseMetadata } from './models/DataResponseMetadata';
-export type { DataSchema } from './models/DataSchema';
-export type { DataSource } from './models/DataSource';
-export type { DataSourceConfiguration } from './models/DataSourceConfiguration';
-export type { DataSourceError } from './models/DataSourceError';
-export type { DataSourceRequest } from './models/DataSourceRequest';
-export type { DataSourceResponse } from './models/DataSourceResponse';
-export { DatePart } from './models/DatePart';
-export type { DatePartGrouping } from './models/DatePartGrouping';
-export type { DatePropertyValue } from './models/DatePropertyValue';
-export type { DateTimeColumnFormat } from './models/DateTimeColumnFormat';
-export type { DateTimeFormat } from './models/DateTimeFormat';
-export type { DateTimePropertyValue } from './models/DateTimePropertyValue';
-export type { DecimalColumnFormat } from './models/DecimalColumnFormat';
-export type { DecimalIntervalGrouping } from './models/DecimalIntervalGrouping';
-export type { DecimalPropertyValue } from './models/DecimalPropertyValue';
-export type { DeleteViewChange } from './models/DeleteViewChange';
-export type { DeleteViewDiff } from './models/DeleteViewDiff';
-export type { DiffBranchResponse } from './models/DiffBranchResponse';
-export type { DoublePropertyValue } from './models/DoublePropertyValue';
-export type { DurationColumnFormat } from './models/DurationColumnFormat';
-export type { EmailConfiguration } from './models/EmailConfiguration';
-export type { Equal } from './models/Equal';
-export type { Equal1 } from './models/Equal1';
-export type { EvictionPolicy } from './models/EvictionPolicy';
-export type { ExportColumnOptions } from './models/ExportColumnOptions';
-export { ExportFormat } from './models/ExportFormat';
-export type { ExportTargetConfiguration } from './models/ExportTargetConfiguration';
-export type { Filter } from './models/Filter';
-export type { FormulaProperty } from './models/FormulaProperty';
-export type { GreaterThan } from './models/GreaterThan';
-export type { GreaterThan1 } from './models/GreaterThan1';
-export type { GreaterThanOrEqual } from './models/GreaterThanOrEqual';
-export type { GreaterThanOrEqual1 } from './models/GreaterThanOrEqual1';
-export type { Grouping } from './models/Grouping';
-export type { Having } from './models/Having';
-export type { In } from './models/In';
-export type { In1 } from './models/In1';
-export type { IntegerIntervalGrouping } from './models/IntegerIntervalGrouping';
-export type { IntegerPropertyValue } from './models/IntegerPropertyValue';
-export type { JdbcAuthentication } from './models/JdbcAuthentication';
-export type { LateBoundEqual } from './models/LateBoundEqual';
-export type { LateBoundEqual1 } from './models/LateBoundEqual1';
-export type { LateBoundGreaterThan } from './models/LateBoundGreaterThan';
-export type { LateBoundGreaterThan1 } from './models/LateBoundGreaterThan1';
-export type { LateBoundGreaterThanOrEqual } from './models/LateBoundGreaterThanOrEqual';
-export type { LateBoundGreaterThanOrEqual1 } from './models/LateBoundGreaterThanOrEqual1';
-export type { LateBoundIn } from './models/LateBoundIn';
-export type { LateBoundIn1 } from './models/LateBoundIn1';
-export type { LateBoundLessThan } from './models/LateBoundLessThan';
-export type { LateBoundLessThan1 } from './models/LateBoundLessThan1';
-export type { LateBoundLessThanOrEqual } from './models/LateBoundLessThanOrEqual';
-export type { LateBoundLessThanOrEqual1 } from './models/LateBoundLessThanOrEqual1';
-export type { LateBoundStringContains } from './models/LateBoundStringContains';
-export type { LateBoundStringContains1 } from './models/LateBoundStringContains1';
-export type { LessThan } from './models/LessThan';
-export type { LessThan1 } from './models/LessThan1';
-export type { LessThanOrEqual } from './models/LessThanOrEqual';
-export type { LessThanOrEqual1 } from './models/LessThanOrEqual1';
-export type { ListBranchResponse } from './models/ListBranchResponse';
-export type { ListNamespacesResponse } from './models/ListNamespacesResponse';
-export type { ListVersionedViewsRequest } from './models/ListVersionedViewsRequest';
-export type { ListViewsRequest } from './models/ListViewsRequest';
-export type { ListViewsResponse } from './models/ListViewsResponse';
-export type { MergeBranchRequest } from './models/MergeBranchRequest';
-export type { MSS } from './models/MSS';
-export type { MySql } from './models/MySql';
-export type { Namespace } from './models/Namespace';
-export type { NamespaceRequest } from './models/NamespaceRequest';
-export type { NamespaceResponse } from './models/NamespaceResponse';
-export type { NamespaceResponseMetadata } from './models/NamespaceResponseMetadata';
-export type { Not } from './models/Not';
-export type { Not1 } from './models/Not1';
-export type { Null } from './models/Null';
-export type { Null1 } from './models/Null1';
-export type { Or } from './models/Or';
-export type { Or1 } from './models/Or1';
-export type { PagingConfiguration } from './models/PagingConfiguration';
-export type { PasswordAuthentication } from './models/PasswordAuthentication';
-export type { Postgres } from './models/Postgres';
-export type { Property } from './models/Property';
-export type { PropertySchema } from './models/PropertySchema';
-export { PropertyType } from './models/PropertyType';
-export type { PropertyValue } from './models/PropertyValue';
-export type { PublicTunnel } from './models/PublicTunnel';
-export type { QueryExecutionError } from './models/QueryExecutionError';
-export type { QueryExecutionResponse } from './models/QueryExecutionResponse';
-export type { QueryExportEmailResponse } from './models/QueryExportEmailResponse';
-export type { QueryExportLinkResponse } from './models/QueryExportLinkResponse';
-export type { QueryExportResponse } from './models/QueryExportResponse';
-export type { QueryPreviewRequest } from './models/QueryPreviewRequest';
-export type { QueryTimeoutError } from './models/QueryTimeoutError';
-export type { Redshift } from './models/Redshift';
-export type { RequestExecutionParameters } from './models/RequestExecutionParameters';
-export type { RequestTelemetry } from './models/RequestTelemetry';
-export type { ScheduledEviction } from './models/ScheduledEviction';
-export type { Snowflake } from './models/Snowflake';
-export type { SnowflakeAuthentication } from './models/SnowflakeAuthentication';
-export type { SnowflakePasswordAuthentication } from './models/SnowflakePasswordAuthentication';
-export type { Sort } from './models/Sort';
-export { SortDirection } from './models/SortDirection';
-export type { SourceProperty } from './models/SourceProperty';
-export type { SSHAuthentication } from './models/SSHAuthentication';
-export type { SSHTunnel } from './models/SSHTunnel';
-export type { StringContains } from './models/StringContains';
-export type { StringContains1 } from './models/StringContains1';
-export type { StringPropertyValue } from './models/StringPropertyValue';
-export type { TablePreviewRequest } from './models/TablePreviewRequest';
-export type { TableView } from './models/TableView';
-export type { Tenant } from './models/Tenant';
-export type { TenantKey } from './models/TenantKey';
-export type { TenantPrivateKeyAuthentication } from './models/TenantPrivateKeyAuthentication';
-export type { TenantRequest } from './models/TenantRequest';
-export type { TenantResponse } from './models/TenantResponse';
-export type { TenantS3Configuration } from './models/TenantS3Configuration';
-export type { TestConnectionRequest } from './models/TestConnectionRequest';
-export type { TestConnectionResponse } from './models/TestConnectionResponse';
-export type { TtlEviction } from './models/TtlEviction';
-export type { Tunnel } from './models/Tunnel';
-export { UnitOfMeasurement } from './models/UnitOfMeasurement';
-export type { UpdateViewChange } from './models/UpdateViewChange';
-export type { UpdateViewDiff } from './models/UpdateViewDiff';
-export type { UUID } from './models/UUID';
-export type { ValueGrouping } from './models/ValueGrouping';
-export type { VendorPrivateKeyAuthentication } from './models/VendorPrivateKeyAuthentication';
-export type { View } from './models/View';
-export type { ViewChange } from './models/ViewChange';
-export type { ViewDiff } from './models/ViewDiff';
-export type { ViewExportRequest } from './models/ViewExportRequest';
-export type { ViewRequest } from './models/ViewRequest';
-export type { ViewResponse } from './models/ViewResponse';
-export type { ViewRunRequest } from './models/ViewRunRequest';
+type And = {
+  "@type": string;
+  values: Array<Filter>;
+};
+type Equal = {
+  "@type": string;
+  propertyId: string;
+  value: PropertyValue;
+};
+type PropertyValue =
+  | BooleanPropertyValue
+  | DatePropertyValue
+  | DateTimePropertyValue
+  | DecimalPropertyValue
+  | DoublePropertyValue
+  | IntegerPropertyValue
+  | StringPropertyValue;
+type BooleanPropertyValue = {
+  "@type": string;
+  value: boolean;
+};
+type DatePropertyValue = {
+  "@type": string;
+  value: string;
+};
+type DateTimePropertyValue = {
+  "@type": string;
+  value: string;
+};
+type DecimalPropertyValue = {
+  "@type": string;
+  value: number;
+};
+type DoublePropertyValue = {
+  "@type": string;
+  value: number;
+};
+type IntegerPropertyValue = {
+  "@type": string;
+  value: number;
+};
+type StringPropertyValue = {
+  "@type": string;
+  value: string;
+};
+type LateBoundEqual = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type In = {
+  "@type": string;
+  propertyId: string;
+  values: Array<PropertyValue>;
+};
+type LateBoundIn = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type LessThan = {
+  "@type": string;
+  propertyId: string;
+  value: PropertyValue;
+};
+type LessThanOrEqual = {
+  "@type": string;
+  propertyId: string;
+  value: PropertyValue;
+};
+type GreaterThan = {
+  "@type": string;
+  propertyId: string;
+  value: PropertyValue;
+};
+type GreaterThanOrEqual = {
+  "@type": string;
+  propertyId: string;
+  value: PropertyValue;
+};
+type LateBoundLessThan = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type LateBoundLessThanOrEqual = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type LateBoundGreaterThan = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type LateBoundGreaterThanOrEqual = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+};
+type Null = {
+  "@type": string;
+  propertyId: string;
+};
+type StringContains = {
+  "@type": string;
+  propertyId: string;
+  value: StringPropertyValue;
+  caseInsensitive: boolean;
+};
+type LateBoundStringContains = {
+  "@type": string;
+  propertyId: string;
+  valueVariableReference: string;
+  caseInsensitive: boolean;
+};
+type And1 = {
+  "@type": string;
+  values: Array<Having>;
+};
+type Equal1 = {
+  "@type": string;
+  property: Property;
+  value: PropertyValue;
+};
+type Property = AggregateProperty | SourceProperty | FormulaProperty;
+type AggregateProperty = {
+  targetPropertyId: string | null;
+  "@type": string;
+  propertyId: string | null;
+  aggregation: Aggregation;
+  aggregationOption?: AggregationOption | undefined;
+};
+type Aggregation =
+  | "avg"
+  | "count"
+  | "count-distinct"
+  | "max"
+  | "min"
+  | "percentile"
+  | "sum";
+type AggregationOption = {
+  decimalValue: number;
+};
+type SourceProperty = {
+  targetPropertyId: string | null;
+  "@type": string;
+  propertyId: string;
+};
+type FormulaProperty = {
+  targetPropertyId: string | null;
+  "@type": string;
+  formula: string;
+};
+type LateBoundEqual1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type In1 = {
+  "@type": string;
+  property: Property;
+  values: Array<PropertyValue>;
+};
+type LateBoundIn1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type LessThan1 = {
+  "@type": string;
+  property: Property;
+  value: PropertyValue;
+};
+type LessThanOrEqual1 = {
+  "@type": string;
+  property: Property;
+  value: PropertyValue;
+};
+type GreaterThan1 = {
+  "@type": string;
+  property: Property;
+  value: PropertyValue;
+};
+type GreaterThanOrEqual1 = {
+  "@type": string;
+  property: Property;
+  value: PropertyValue;
+};
+type LateBoundLessThan1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type LateBoundLessThanOrEqual1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type LateBoundGreaterThan1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type LateBoundGreaterThanOrEqual1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+};
+type Null1 = {
+  "@type": string;
+  property: Property;
+};
+type StringContains1 = {
+  "@type": string;
+  property: Property;
+  value: StringPropertyValue;
+  caseInsensitive: boolean;
+};
+type LateBoundStringContains1 = {
+  "@type": string;
+  property: Property;
+  valueVariableReference: string;
+  caseInsensitive: boolean;
+};
+type Filter =
+  | And
+  | Or
+  | Not
+  | Equal
+  | LateBoundEqual
+  | In
+  | LateBoundIn
+  | LessThan
+  | LessThanOrEqual
+  | GreaterThan
+  | GreaterThanOrEqual
+  | LateBoundLessThan
+  | LateBoundLessThanOrEqual
+  | LateBoundGreaterThan
+  | LateBoundGreaterThanOrEqual
+  | Null
+  | StringContains
+  | LateBoundStringContains;
+type Folder = {
+  name: string;
+  path: string | null;
+  description: string | null;
+  id?: (string | null) | undefined;
+  versionId?: (string | null) | undefined;
+  "@type": string;
+  children: Array<Resource> | null;
+};
+type ComputedView = {
+  columnDefinitions: Array<PropertySchema>;
+  namespaceId?: (string | null) | undefined;
+  name: string;
+  path: string | null;
+  description: string | null;
+  id?: (string | null) | undefined;
+  versionId?: (string | null) | undefined;
+  "@type": string;
+  query: string;
+  cacheable?: boolean | undefined;
+  parameters: Array<Parameter>;
+  cacheEvictionPolicy: EvictionPolicy;
+};
+type PropertySchema = {
+  array?: boolean | undefined;
+  id: string;
+  name?: (string | null) | undefined;
+  type: PropertyType;
+};
+type PropertyType =
+  | "boolean"
+  | "date"
+  | "datetime"
+  | "decimal"
+  | "double"
+  | "integer"
+  | "long"
+  | "string"
+  | "unsupported";
+type Parameter = {
+  name: string;
+  description: string | null;
+  required: boolean;
+};
+type EvictionPolicy = ScheduledEviction | TtlEviction;
+type ScheduledEviction = {
+  "@type": string;
+  evictionSchedule: string;
+};
+type TtlEviction = {
+  "@type": string;
+  ttl: string;
+};
+type TableView = {
+  columnDefinitions: Array<PropertySchema>;
+  namespaceId?: (string | null) | undefined;
+  name: string;
+  path: string | null;
+  description: string | null;
+  id?: (string | null) | undefined;
+  versionId?: (string | null) | undefined;
+  "@type": string;
+  tableName: string;
+  schemaName?: (string | null) | undefined;
+};
+type Having =
+  | And1
+  | Or1
+  | Not1
+  | Equal1
+  | LateBoundEqual1
+  | In1
+  | LateBoundIn1
+  | LessThan1
+  | LessThanOrEqual1
+  | GreaterThan1
+  | GreaterThanOrEqual1
+  | LateBoundLessThan1
+  | LateBoundLessThanOrEqual1
+  | LateBoundGreaterThan1
+  | LateBoundGreaterThanOrEqual1
+  | Null1
+  | StringContains1
+  | LateBoundStringContains1;
+type Not = {
+  "@type": string;
+  value: Filter;
+};
+type Not1 = {
+  "@type": string;
+  value: Having;
+};
+type Or = {
+  "@type": string;
+  values: Array<Filter>;
+};
+type Or1 = {
+  "@type": string;
+  values: Array<Having>;
+};
+type Resource = ComputedView | TableView | Folder;
+type SSHTunnel = {
+  "@type": string;
+  tunnel: Tunnel;
+  host: string;
+  port?: number | undefined;
+  authentication: SSHAuthentication;
+};
+type PublicTunnel = {
+  "@type": string;
+};
+type SSHAuthentication =
+  | VendorPrivateKeyAuthentication
+  | TenantPrivateKeyAuthentication;
+type VendorPrivateKeyAuthentication = {
+  username: string;
+  "@type": string;
+};
+type TenantPrivateKeyAuthentication = {
+  username: string;
+  "@type": string;
+  privateKey?: (string | null) | undefined;
+};
+type Tunnel = PublicTunnel | SSHTunnel;
 
-export { BranchResourceService } from './services/BranchResourceService';
-export { CommitResourceService } from './services/CommitResourceService';
-export { DataSourceResourceService } from './services/DataSourceResourceService';
-export { HealthResourceService } from './services/HealthResourceService';
-export { ListViewsResourceService } from './services/ListViewsResourceService';
-export { NamespaceResourceService } from './services/NamespaceResourceService';
-export { QueryResourceService } from './services/QueryResourceService';
-export { TenantResourceService } from './services/TenantResourceService';
-export { TestConnectionResourceService } from './services/TestConnectionResourceService';
-export { ViewResourceService } from './services/ViewResourceService';
+const Branch = z
+  .object({
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .optional(),
+    name: z
+      .string()
+      .max(200)
+      .regex(/^[a-zA-Z0-9_-]+$/),
+    headId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid(),
+  })
+  .passthrough();
+const ListBranchResponse = z
+  .object({ branches: z.array(Branch) })
+  .passthrough();
+const ClientError = z
+  .object({
+    status: z.number().int().gte(100).lte(599),
+    message: z.string().regex(/\S/),
+  })
+  .passthrough();
+const BranchRequest = z.object({ branch: Branch }).passthrough();
+const PropertyType = z.enum([
+  "boolean",
+  "date",
+  "datetime",
+  "decimal",
+  "double",
+  "integer",
+  "long",
+  "string",
+  "unsupported",
+]);
+const PropertySchema = z
+  .object({
+    array: z.boolean().optional(),
+    id: z.string().regex(/\S/),
+    name: z.string().nullish(),
+    type: PropertyType,
+  })
+  .passthrough();
+const Parameter = z
+  .object({
+    name: z.string().regex(/\S/),
+    description: z.string().nullable(),
+    required: z.boolean(),
+  })
+  .passthrough();
+const ScheduledEviction = z
+  .object({ "@type": z.string(), evictionSchedule: z.string() })
+  .passthrough();
+const TtlEviction = z
+  .object({ "@type": z.string(), ttl: z.string() })
+  .passthrough();
+const EvictionPolicy = z.discriminatedUnion("@type", [
+  ScheduledEviction,
+  TtlEviction,
+]);
+const ComputedView = z
+  .object({
+    columnDefinitions: z.array(PropertySchema),
+    namespaceId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    name: z.string().max(200).regex(/\S/),
+    path: z.string().nullable(),
+    description: z.string().nullable(),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    versionId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    "@type": z.string(),
+    query: z.string(),
+    cacheable: z.boolean().optional(),
+    parameters: z.array(Parameter),
+    cacheEvictionPolicy: EvictionPolicy.nullable(),
+  })
+  .passthrough();
+const TableView = z
+  .object({
+    columnDefinitions: z.array(PropertySchema),
+    namespaceId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    name: z.string().max(200).regex(/\S/),
+    path: z.string().nullable(),
+    description: z.string().nullable(),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    versionId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    "@type": z.string(),
+    tableName: z.string().max(200).regex(/\S/),
+    schemaName: z.string().nullish(),
+  })
+  .passthrough();
+const Folder: z.ZodType<Folder> = z.lazy(() =>
+  z
+    .object({
+      name: z.string().max(200).regex(/\S/),
+      path: z.string().nullable(),
+      description: z.string().nullable(),
+      id: z
+        .string()
+        .regex(
+          /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+        )
+        .uuid()
+        .nullish(),
+      versionId: z
+        .string()
+        .regex(
+          /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+        )
+        .uuid()
+        .nullish(),
+      "@type": z.string(),
+      children: z.array(Resource).nullable(),
+    })
+    .passthrough()
+);
+const Resource: z.ZodType<Resource> = z.lazy(() =>
+  z.discriminatedUnion("@type", [ComputedView, TableView, Folder])
+);
+const CreateResourceDiff = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const DeleteResourceDiff = z
+  .object({ "@type": z.string(), originalResource: Resource })
+  .passthrough();
+const UpdateResourceDiff = z
+  .object({
+    "@type": z.string(),
+    originalResource: Resource,
+    updatedResource: Resource,
+  })
+  .passthrough();
+const ResourceDiff = z.discriminatedUnion("@type", [
+  CreateResourceDiff,
+  DeleteResourceDiff,
+  UpdateResourceDiff,
+]);
+const BranchResponseMetadata = z
+  .object({ diff: z.array(ResourceDiff).nullable() })
+  .passthrough();
+const BranchResponse = z
+  .object({ branch: Branch, meta: BranchResponseMetadata.nullable() })
+  .passthrough();
+const DiffBranchResponse = z
+  .object({ diff: z.array(ResourceDiff) })
+  .passthrough();
+const UUID = z.string();
+const CreateResourceChange = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const UpdateResourceChange = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const DeleteResourceChange = z
+  .object({
+    "@type": z.string(),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid(),
+  })
+  .passthrough();
+const ResourceChange = z.discriminatedUnion("@type", [
+  CreateResourceChange,
+  UpdateResourceChange,
+  DeleteResourceChange,
+]);
+const CreateCommitRequest = z
+  .object({
+    commitMessage: z.string().max(1000).regex(/\S/),
+    parentCommitId: UUID.regex(
+      /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    ).uuid(),
+    changes: z.array(ResourceChange),
+  })
+  .passthrough();
+const CreateCommitResponse = z
+  .object({
+    commitId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid(),
+    changes: z.array(ResourceChange),
+  })
+  .passthrough();
+const ListBranchContentResponse = z.object({ content: Resource }).passthrough();
+const MergeBranchRequest = z
+  .object({
+    commitMessage: z.string(),
+    sourceBranchId: UUID.regex(
+      /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    ).uuid(),
+  })
+  .passthrough();
+const PasswordAuthentication = z
+  .object({
+    "@type": z.string(),
+    username: z.string().regex(/\S/),
+    password: z.string().nullish(),
+  })
+  .passthrough();
+const JdbcAuthentication = PasswordAuthentication;
+const PublicTunnel = z.object({ "@type": z.string() }).passthrough();
+const VendorPrivateKeyAuthentication = z
+  .object({ username: z.string().regex(/\S/), "@type": z.string() })
+  .passthrough();
+const TenantPrivateKeyAuthentication = z
+  .object({
+    username: z.string().regex(/\S/),
+    "@type": z.string(),
+    privateKey: z.string().nullish(),
+  })
+  .passthrough();
+const SSHAuthentication = z.discriminatedUnion("@type", [
+  VendorPrivateKeyAuthentication,
+  TenantPrivateKeyAuthentication,
+]);
+const SSHTunnel: z.ZodType<SSHTunnel> = z.lazy(() =>
+  z
+    .object({
+      "@type": z.string(),
+      tunnel: Tunnel,
+      host: z.string().regex(/\S/),
+      port: z.number().int().gte(1).lte(65536).optional(),
+      authentication: SSHAuthentication,
+    })
+    .passthrough()
+);
+const Tunnel: z.ZodType<Tunnel> = z.lazy(() =>
+  z.discriminatedUnion("@type", [PublicTunnel, SSHTunnel])
+);
+const Postgres = z
+  .object({
+    authentication: JdbcAuthentication,
+    database: z.string().regex(/\S/),
+    host: z.string().regex(/\S/),
+    tunnel: Tunnel,
+    "@type": z.string(),
+    port: z.number().int().optional(),
+  })
+  .passthrough();
+const MySql = z
+  .object({
+    authentication: JdbcAuthentication,
+    database: z.string().regex(/\S/),
+    host: z.string().regex(/\S/),
+    tunnel: Tunnel,
+    "@type": z.string(),
+    port: z.number().int().optional(),
+  })
+  .passthrough();
+const MSS = z
+  .object({
+    authentication: JdbcAuthentication,
+    database: z.string().regex(/\S/),
+    host: z.string().regex(/\S/),
+    tunnel: Tunnel,
+    "@type": z.string(),
+    port: z.number().int().optional(),
+  })
+  .passthrough();
+const BigQueryAuthentication = z
+  .object({
+    projectId: z.string().nullable(),
+    jsonKeyFile: z.string().nullable(),
+  })
+  .partial()
+  .passthrough();
+const BigQuery = z
+  .object({
+    tunnel: Tunnel,
+    "@type": z.string(),
+    authentication: BigQueryAuthentication,
+  })
+  .passthrough();
+const Redshift = z
+  .object({
+    authentication: JdbcAuthentication,
+    database: z.string().regex(/\S/),
+    host: z.string().regex(/\S/),
+    tunnel: Tunnel,
+    "@type": z.string(),
+    port: z.number().int().optional(),
+  })
+  .passthrough();
+const SnowflakePasswordAuthentication = z
+  .object({ "@type": z.string(), password: z.string().nullish() })
+  .passthrough();
+const SnowflakeAuthentication = SnowflakePasswordAuthentication;
+const Snowflake = z
+  .object({
+    tunnel: Tunnel,
+    "@type": z.string(),
+    user: z.string().regex(/\S/),
+    account: z.string().regex(/\S/),
+    schema: z.string().nullable(),
+    database: z.string().nullable(),
+    authentication: SnowflakeAuthentication,
+  })
+  .passthrough();
+const ClickhouseConnectionType = z.enum(["HTTP", "NATIVE"]);
+const Clickhouse = z
+  .object({
+    authentication: JdbcAuthentication,
+    database: z.string().regex(/\S/),
+    host: z.string().regex(/\S/),
+    tunnel: Tunnel,
+    "@type": z.string(),
+    port: z.number().int().optional(),
+    connectionType: ClickhouseConnectionType.optional(),
+  })
+  .passthrough();
+const DataSourceConfiguration = z.discriminatedUnion("@type", [
+  Postgres,
+  MySql,
+  MSS,
+  BigQuery,
+  Redshift,
+  Snowflake,
+  Clickhouse,
+]);
+const TestConnectionRequest = z
+  .object({ configuration: DataSourceConfiguration })
+  .passthrough();
+const Namespace = z
+  .object({
+    name: z.string().max(200).regex(/\S/),
+    ignoreTableList: z.array(z.string()).optional(),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .optional(),
+  })
+  .passthrough();
+const NamespaceRequest = z.object({ namespace: Namespace }).passthrough();
+const DataSource = z
+  .object({
+    name: z.string().max(200).regex(/\S/),
+    externalId: z.string().max(200).regex(/\S/),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .optional(),
+    namespaceId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .optional(),
+    configuration: DataSourceConfiguration,
+  })
+  .passthrough();
+const NamespaceResponseMetadata = z
+  .object({
+    dataSources: z.array(DataSource).nullable(),
+    resources: z.array(Resource).nullable(),
+    views: z.array(Resource).nullable(),
+  })
+  .passthrough();
+const NamespaceResponse = z
+  .object({ namespace: Namespace, meta: NamespaceResponseMetadata.nullable() })
+  .passthrough();
+const DataSourceRequest = z.object({ dataSource: DataSource }).passthrough();
+const DataSourceResponse = z.object({ dataSource: DataSource }).passthrough();
+const PagingConfiguration = z
+  .object({ perPage: z.number().int().gte(1), page: z.number().int().gte(0) })
+  .partial()
+  .passthrough();
+const DataRequestParameters = z
+  .object({
+    pagingConfiguration: PagingConfiguration,
+    includeTotalResults: z.boolean(),
+  })
+  .partial()
+  .passthrough();
+const And: z.ZodType<And> = z.lazy(() =>
+  z
+    .object({ "@type": z.string(), values: z.array(Filter).min(1) })
+    .passthrough()
+);
+const Or: z.ZodType<Or> = z.lazy(() =>
+  z
+    .object({ "@type": z.string(), values: z.array(Filter).min(1) })
+    .passthrough()
+);
+const Not: z.ZodType<Not> = z.lazy(() =>
+  z.object({ "@type": z.string(), value: Filter }).passthrough()
+);
+const BooleanPropertyValue = z
+  .object({ "@type": z.string(), value: z.boolean() })
+  .passthrough();
+const DatePropertyValue = z
+  .object({ "@type": z.string(), value: z.string() })
+  .passthrough();
+const DateTimePropertyValue = z
+  .object({ "@type": z.string(), value: z.string().datetime({ offset: true }) })
+  .passthrough();
+const DecimalPropertyValue = z
+  .object({ "@type": z.string(), value: z.number() })
+  .passthrough();
+const DoublePropertyValue = z
+  .object({ "@type": z.string(), value: z.number() })
+  .passthrough();
+const IntegerPropertyValue = z
+  .object({ "@type": z.string(), value: z.number().int() })
+  .passthrough();
+const StringPropertyValue = z
+  .object({ "@type": z.string(), value: z.string() })
+  .passthrough();
+const PropertyValue = z.discriminatedUnion("@type", [
+  BooleanPropertyValue,
+  DatePropertyValue,
+  DateTimePropertyValue,
+  DecimalPropertyValue,
+  DoublePropertyValue,
+  IntegerPropertyValue,
+  StringPropertyValue,
+]);
+const Equal = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LateBoundEqual = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const In = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    values: z.array(PropertyValue),
+  })
+  .passthrough();
+const LateBoundIn = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LessThan = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LessThanOrEqual = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const GreaterThan = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const GreaterThanOrEqual = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LateBoundLessThan = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundLessThanOrEqual = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThan = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThanOrEqual = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const Null = z
+  .object({ "@type": z.string(), propertyId: z.string().regex(/\S/) })
+  .passthrough();
+const StringContains = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: StringPropertyValue,
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const LateBoundStringContains = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const Filter: z.ZodType<Filter> = z.lazy(() =>
+  z.discriminatedUnion("@type", [
+    And,
+    Or,
+    Not,
+    Equal,
+    LateBoundEqual,
+    In,
+    LateBoundIn,
+    LessThan,
+    LessThanOrEqual,
+    GreaterThan,
+    GreaterThanOrEqual,
+    LateBoundLessThan,
+    LateBoundLessThanOrEqual,
+    LateBoundGreaterThan,
+    LateBoundGreaterThanOrEqual,
+    Null,
+    StringContains,
+    LateBoundStringContains,
+  ])
+);
+const Aggregation = z.enum([
+  "avg",
+  "count",
+  "count-distinct",
+  "max",
+  "min",
+  "percentile",
+  "sum",
+]);
+const AggregationOption = z.object({ decimalValue: z.number() }).passthrough();
+const AggregateProperty = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    propertyId: z.string().nullable(),
+    aggregation: Aggregation,
+    aggregationOption: AggregationOption.nullish(),
+  })
+  .passthrough();
+const SourceProperty = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+  })
+  .passthrough();
+const FormulaProperty = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    formula: z.string(),
+  })
+  .passthrough();
+const Property = z.discriminatedUnion("@type", [
+  AggregateProperty,
+  SourceProperty,
+  FormulaProperty,
+]);
+const CalendarInterval = z.enum([
+  "year",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute",
+]);
+const CalendarIntervalGrouping = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    calendarInterval: CalendarInterval,
+    targetTimezone: z.string().optional(),
+  })
+  .passthrough();
+const DatePart = z.enum([
+  "day-of-week",
+  "day-of-month",
+  "month-of-year",
+  "hour-of-day",
+]);
+const DatePartGrouping = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    datePart: DatePart,
+    targetTimezone: z.string().optional(),
+  })
+  .passthrough();
+const DecimalIntervalGrouping = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    interval: z.number().gt(0),
+  })
+  .passthrough();
+const IntegerIntervalGrouping = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    interval: z.number().int().gt(0),
+  })
+  .passthrough();
+const ValueGrouping = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+  })
+  .passthrough();
+const Grouping = z.discriminatedUnion("@type", [
+  CalendarIntervalGrouping,
+  DatePartGrouping,
+  DecimalIntervalGrouping,
+  IntegerIntervalGrouping,
+  ValueGrouping,
+]);
+const SortDirection = z.enum(["asc", "desc"]);
+const Sort = z
+  .object({ sortDirection: SortDirection, propertyId: z.string().regex(/\S/) })
+  .passthrough();
+const And1: z.ZodType<And1> = z.lazy(() =>
+  z
+    .object({ "@type": z.string(), values: z.array(Having).min(1) })
+    .passthrough()
+);
+const Or1: z.ZodType<Or1> = z.lazy(() =>
+  z
+    .object({ "@type": z.string(), values: z.array(Having).min(1) })
+    .passthrough()
+);
+const Not1: z.ZodType<Not1> = z.lazy(() =>
+  z.object({ "@type": z.string(), value: Having }).passthrough()
+);
+const Equal1 = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LateBoundEqual1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const In1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    values: z.array(PropertyValue),
+  })
+  .passthrough();
+const LateBoundIn1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LessThan1 = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LessThanOrEqual1 = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const GreaterThan1 = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const GreaterThanOrEqual1 = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LateBoundLessThan1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundLessThanOrEqual1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThan1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThanOrEqual1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const Null1 = z
+  .object({ "@type": z.string(), property: Property })
+  .passthrough();
+const StringContains1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    value: StringPropertyValue,
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const LateBoundStringContains1 = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const Having: z.ZodType<Having> = z.lazy(() =>
+  z.discriminatedUnion("@type", [
+    And1,
+    Or1,
+    Not1,
+    Equal1,
+    LateBoundEqual1,
+    In1,
+    LateBoundIn1,
+    LessThan1,
+    LessThanOrEqual1,
+    GreaterThan1,
+    GreaterThanOrEqual1,
+    LateBoundLessThan1,
+    LateBoundLessThanOrEqual1,
+    LateBoundGreaterThan1,
+    LateBoundGreaterThanOrEqual1,
+    Null1,
+    StringContains1,
+    LateBoundStringContains1,
+  ])
+);
+const Computation = z
+  .object({
+    filter: Filter.nullable(),
+    properties: z.array(Property),
+    groupings: z.array(Grouping),
+    sorts: z.array(Sort),
+    having: Having.nullable(),
+    includeRollup: z.boolean().optional(),
+  })
+  .passthrough();
+const QueryPreviewRequest = z
+  .object({
+    query: z.string().regex(/\S/),
+    dataRequestParameters: DataRequestParameters,
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+  })
+  .passthrough();
+const DataRecord = z
+  .object({ propertyValues: z.record(z.array(PropertyValue)) })
+  .passthrough();
+const DataPage = z.object({ dataRecords: z.array(DataRecord) }).passthrough();
+const DataSchema = z
+  .object({ propertySchema: z.array(PropertySchema) })
+  .passthrough();
+const DataResponseMetadata = z
+  .object({
+    schema: DataSchema,
+    totalResults: z.number().int().nullable(),
+    renderedQuery: z.string().nullable(),
+  })
+  .passthrough();
+const CacheTelemetry = z
+  .object({
+    cacheHit: z.boolean(),
+    recordedAt: z.string().datetime({ offset: true }).nullable(),
+    ttl: z.string().nullable(),
+  })
+  .passthrough();
+const RequestTelemetry = z
+  .object({
+    requestTime: z.string().nullable(),
+    queryTime: z.string().nullable(),
+    processingTime: z.string().nullable(),
+    cacheTelemetry: CacheTelemetry.nullish(),
+  })
+  .passthrough();
+const QueryExecutionResponse = z
+  .object({
+    data: DataPage,
+    meta: DataResponseMetadata,
+    requestTelemetry: RequestTelemetry.nullable(),
+  })
+  .passthrough();
+const QueryExecutionError = z
+  .object({
+    renderedQuery: z.string().nullable(),
+    requestTelemetry: RequestTelemetry.nullable(),
+    message: z.string().nullable(),
+    "@type": z.string(),
+  })
+  .passthrough();
+const TablePreviewRequest = z
+  .object({
+    tableIdentifier: z.string().regex(/\S/),
+    dataRequestParameters: DataRequestParameters,
+  })
+  .passthrough();
+const ExportFormat = z.enum(["CSV", "TSV", "XLSX"]);
+const DateTimeFormat = z
+  .object({ pattern: z.string(), exportFormat: z.string().optional() })
+  .passthrough();
+const DateTimeColumnFormat = z
+  .object({
+    "@type": z.string(),
+    dateTimeFormatPattern: DateTimeFormat.nullish(),
+    pattern: z.string().nullish(),
+    locale: z.string().nullable(),
+    targetTimezone: z.string().optional(),
+  })
+  .passthrough();
+const UnitOfMeasurement = z.literal("CURRENCY");
+const DecimalColumnFormat = z
+  .object({
+    "@type": z.string(),
+    decimalFormat: z.string().nullable(),
+    locale: z.string().nullable(),
+    unitOfMeasurement: UnitOfMeasurement.optional(),
+    zeroReplacement: z.string().nullable(),
+    multiplier: z.number().nullable(),
+  })
+  .passthrough();
+const DurationColumnFormat = z
+  .object({ "@type": z.string(), durationPattern: z.string().nullable() })
+  .passthrough();
+const ColumnFormat = z.discriminatedUnion("@type", [
+  DateTimeColumnFormat,
+  DecimalColumnFormat,
+  DurationColumnFormat,
+]);
+const ExportColumnOptions = z
+  .object({
+    targetPropertyId: z.string(),
+    displayName: z.string().nullable(),
+    columnFormat: ColumnFormat.nullable(),
+  })
+  .passthrough();
+const ExportTargetConfiguration = z
+  .object({
+    fileName: z.string().nullable(),
+    exportFormat: ExportFormat,
+    columnDisplayOptions: z.array(ExportColumnOptions),
+  })
+  .passthrough();
+const EmailConfiguration = z
+  .object({
+    recipientEmails: z.array(z.string()).min(1),
+    subject: z.string().nullable(),
+    body: z.string().nullable(),
+  })
+  .passthrough();
+const ViewExportRequest = z
+  .object({
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+    exportConfiguration: ExportTargetConfiguration,
+    emailConfiguration: EmailConfiguration.nullable(),
+  })
+  .passthrough();
+const QueryExportEmailResponse = z
+  .object({ "@type": z.string() })
+  .passthrough();
+const QueryExportLinkResponse = z
+  .object({ "@type": z.string(), url: z.string().regex(/\S/) })
+  .passthrough();
+const QueryExportResponse = z.discriminatedUnion("@type", [
+  QueryExportEmailResponse,
+  QueryExportLinkResponse,
+]);
+const RequestExecutionParameters = z
+  .object({ forceRefresh: z.boolean() })
+  .partial()
+  .passthrough();
+const ViewRunRequest = z
+  .object({
+    dataRequestParameters: DataRequestParameters,
+    requestExecutionParameters: RequestExecutionParameters.nullable(),
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+  })
+  .passthrough();
+const View = z
+  .object({
+    name: z.string().max(200).regex(/\S/),
+    path: z.string().nullable(),
+    description: z.string().nullable(),
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    versionId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+    columnDefinitions: z.array(PropertySchema),
+    namespaceId: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid()
+      .nullish(),
+  })
+  .passthrough();
+const ViewResponse = z.object({ view: View }).passthrough();
+const ListViewsResponse = z
+  .object({ views: z.array(ViewResponse) })
+  .passthrough();
+const TenantS3Configuration = z
+  .object({
+    prefix: z.string(),
+    bucket: z.string(),
+    region: z.string(),
+    roleArn: z.string(),
+  })
+  .passthrough();
+const TenantRequest = z
+  .object({
+    configurationOverrides: z.record(z.string()).optional(),
+    s3Configuration: TenantS3Configuration.nullable(),
+  })
+  .passthrough();
+const TenantKey = z
+  .object({
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid(),
+    createdAt: z.string().datetime({ offset: true }),
+    value: z.string().nullable(),
+  })
+  .passthrough();
+const Tenant = z
+  .object({
+    id: z
+      .string()
+      .regex(
+        /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+      )
+      .uuid(),
+    keys: z.array(TenantKey).optional(),
+    configurationOverrides: z.record(z.string()).optional(),
+    s3Configuration: TenantS3Configuration.nullable(),
+  })
+  .passthrough();
+const TenantResponse = z.object({ tenant: Tenant }).passthrough();
+const VersionedViewRequest = z
+  .object({
+    id: UUID.regex(
+      /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    ).uuid(),
+    versionId: UUID.regex(
+      /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    ).uuid(),
+  })
+  .passthrough();
+const ListVersionedViewsRequest = z
+  .object({ requests: z.array(VersionedViewRequest) })
+  .passthrough();
+
+export const schemas = {
+  Branch,
+  ListBranchResponse,
+  ClientError,
+  BranchRequest,
+  PropertyType,
+  PropertySchema,
+  Parameter,
+  ScheduledEviction,
+  TtlEviction,
+  EvictionPolicy,
+  ComputedView,
+  TableView,
+  Folder,
+  Resource,
+  CreateResourceDiff,
+  DeleteResourceDiff,
+  UpdateResourceDiff,
+  ResourceDiff,
+  BranchResponseMetadata,
+  BranchResponse,
+  DiffBranchResponse,
+  UUID,
+  CreateResourceChange,
+  UpdateResourceChange,
+  DeleteResourceChange,
+  ResourceChange,
+  CreateCommitRequest,
+  CreateCommitResponse,
+  ListBranchContentResponse,
+  MergeBranchRequest,
+  PasswordAuthentication,
+  JdbcAuthentication,
+  PublicTunnel,
+  VendorPrivateKeyAuthentication,
+  TenantPrivateKeyAuthentication,
+  SSHAuthentication,
+  SSHTunnel,
+  Tunnel,
+  Postgres,
+  MySql,
+  MSS,
+  BigQueryAuthentication,
+  BigQuery,
+  Redshift,
+  SnowflakePasswordAuthentication,
+  SnowflakeAuthentication,
+  Snowflake,
+  ClickhouseConnectionType,
+  Clickhouse,
+  DataSourceConfiguration,
+  TestConnectionRequest,
+  Namespace,
+  NamespaceRequest,
+  DataSource,
+  NamespaceResponseMetadata,
+  NamespaceResponse,
+  DataSourceRequest,
+  DataSourceResponse,
+  PagingConfiguration,
+  DataRequestParameters,
+  And,
+  Or,
+  Not,
+  BooleanPropertyValue,
+  DatePropertyValue,
+  DateTimePropertyValue,
+  DecimalPropertyValue,
+  DoublePropertyValue,
+  IntegerPropertyValue,
+  StringPropertyValue,
+  PropertyValue,
+  Equal,
+  LateBoundEqual,
+  In,
+  LateBoundIn,
+  LessThan,
+  LessThanOrEqual,
+  GreaterThan,
+  GreaterThanOrEqual,
+  LateBoundLessThan,
+  LateBoundLessThanOrEqual,
+  LateBoundGreaterThan,
+  LateBoundGreaterThanOrEqual,
+  Null,
+  StringContains,
+  LateBoundStringContains,
+  Filter,
+  Aggregation,
+  AggregationOption,
+  AggregateProperty,
+  SourceProperty,
+  FormulaProperty,
+  Property,
+  CalendarInterval,
+  CalendarIntervalGrouping,
+  DatePart,
+  DatePartGrouping,
+  DecimalIntervalGrouping,
+  IntegerIntervalGrouping,
+  ValueGrouping,
+  Grouping,
+  SortDirection,
+  Sort,
+  And1,
+  Or1,
+  Not1,
+  Equal1,
+  LateBoundEqual1,
+  In1,
+  LateBoundIn1,
+  LessThan1,
+  LessThanOrEqual1,
+  GreaterThan1,
+  GreaterThanOrEqual1,
+  LateBoundLessThan1,
+  LateBoundLessThanOrEqual1,
+  LateBoundGreaterThan1,
+  LateBoundGreaterThanOrEqual1,
+  Null1,
+  StringContains1,
+  LateBoundStringContains1,
+  Having,
+  Computation,
+  QueryPreviewRequest,
+  DataRecord,
+  DataPage,
+  DataSchema,
+  DataResponseMetadata,
+  CacheTelemetry,
+  RequestTelemetry,
+  QueryExecutionResponse,
+  QueryExecutionError,
+  TablePreviewRequest,
+  ExportFormat,
+  DateTimeFormat,
+  DateTimeColumnFormat,
+  UnitOfMeasurement,
+  DecimalColumnFormat,
+  DurationColumnFormat,
+  ColumnFormat,
+  ExportColumnOptions,
+  ExportTargetConfiguration,
+  EmailConfiguration,
+  ViewExportRequest,
+  QueryExportEmailResponse,
+  QueryExportLinkResponse,
+  QueryExportResponse,
+  RequestExecutionParameters,
+  ViewRunRequest,
+  View,
+  ViewResponse,
+  ListViewsResponse,
+  TenantS3Configuration,
+  TenantRequest,
+  TenantKey,
+  Tenant,
+  TenantResponse,
+  VersionedViewRequest,
+  ListVersionedViewsRequest,
+};
+
+const endpoints = makeApi([
+  {
+    method: "get",
+    path: "/v1/branches",
+    alias: "listBranches",
+    requestFormat: "json",
+    response: ListBranchResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/branches",
+    alias: "createBranch",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Branch to create`,
+        type: "Body",
+        schema: BranchRequest,
+      },
+    ],
+    response: BranchResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/branches/:branchId/commits",
+    alias: "createCommit",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Branch to create`,
+        type: "Body",
+        schema: CreateCommitRequest,
+      },
+      {
+        name: "branchId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: CreateCommitResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/branches/:id",
+    alias: "getBranch",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "includeMeta",
+        type: "Query",
+        schema: z.boolean().optional().default(false),
+      },
+    ],
+    response: BranchResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/branches/:id/contents:path",
+    alias: "listBranchContent",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "path",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(/(\/.+)?/)
+          .default("/"),
+      },
+      {
+        name: "page",
+        type: "Query",
+        schema: z.number().int().optional().default(0),
+      },
+      {
+        name: "perPage",
+        type: "Query",
+        schema: z.number().int().optional().default(50),
+      },
+    ],
+    response: ListBranchContentResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/branches/:targetBranchId/merge",
+    alias: "mergeBranch",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Options for merge`,
+        type: "Body",
+        schema: MergeBranchRequest,
+      },
+      {
+        name: "targetBranchId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "isForce",
+        type: "Query",
+        schema: z.boolean(),
+      },
+    ],
+    response: BranchResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/branches/diff",
+    alias: "diffBranch",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "from",
+        type: "Query",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid()
+          .optional(),
+      },
+      {
+        name: "to",
+        type: "Query",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid()
+          .optional(),
+      },
+    ],
+    response: DiffBranchResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/data-sources/retest-connection/:id",
+    alias: "retestConnection",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Data Source configuration to retry to connect to`,
+        type: "Body",
+        schema: TestConnectionRequest,
+      },
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: z
+      .object({ numberOfTables: z.number().int().gte(0) })
+      .passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/data-sources/test-connection",
+    alias: "testConnection",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Data Source configuration to try to connect to`,
+        type: "Body",
+        schema: TestConnectionRequest,
+      },
+    ],
+    response: z
+      .object({ numberOfTables: z.number().int().gte(0) })
+      .passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/health",
+    alias: "getFidoHealth",
+    requestFormat: "json",
+    response: z.object({}).partial().passthrough(),
+  },
+  {
+    method: "get",
+    path: "/v1/health/data-source-connection/:namespaceId/:dataSourceId",
+    alias: "getDataSourceConnectionHealth",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: z.object({}).partial().passthrough(),
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces",
+    alias: "createNamespace",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Namespace object to create`,
+        type: "Body",
+        schema: NamespaceRequest,
+      },
+    ],
+    response: NamespaceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/:id",
+    alias: "getNamespace",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "includeDataSources",
+        type: "Query",
+        schema: z.boolean().optional().default(false),
+      },
+      {
+        name: "includeViews",
+        type: "Query",
+        schema: z.boolean().optional().default(false),
+      },
+    ],
+    response: NamespaceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "put",
+    path: "/v1/namespaces/:id",
+    alias: "updateNamespace",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Namespace object to update`,
+        type: "Body",
+        schema: NamespaceRequest,
+      },
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: NamespaceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "delete",
+    path: "/v1/namespaces/:id",
+    alias: "deleteNamespace",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: z.object({}).partial().passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources",
+    alias: "createDataSource",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Data Source object to create`,
+        type: "Body",
+        schema: DataSourceRequest,
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: DataSourceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/preview",
+    alias: "getQueryPreview",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Query to preview against the provided data source`,
+        type: "Body",
+        schema: QueryPreviewRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExecutionResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+      {
+        status: 503,
+        description: `An error related to the execution of the request`,
+        schema: QueryExecutionError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/preview-table",
+    alias: "getTablePreview",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Table to preview against the provided data source`,
+        type: "Body",
+        schema: TablePreviewRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExecutionResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/views/:viewId/export",
+    alias: "exportView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `View to export against the provided data source`,
+        type: "Body",
+        schema: ViewExportRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "viewId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExportResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/views/:viewId/run",
+    alias: "runView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `View to run against the provided data source`,
+        type: "Body",
+        schema: ViewRunRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "viewId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExecutionResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+      {
+        status: 503,
+        description: `An error related to the execution of the request`,
+        schema: QueryExecutionError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/views/:viewId/versions/:versionId/export",
+    alias: "exportVersionedView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Request options for the export`,
+        type: "Body",
+        schema: ViewExportRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "versionId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "viewId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExportResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/views/:viewId/versions/:versionId/run",
+    alias: "runVersionedView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Request options for the query`,
+        type: "Body",
+        schema: ViewRunRequest,
+      },
+      {
+        name: "dataSourceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "versionId",
+        type: "Path",
+        schema: z.string(),
+      },
+      {
+        name: "viewId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: QueryExecutionResponse,
+    errors: [
+      {
+        status: 400,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+      {
+        status: 503,
+        description: `An error related to the execution of the request`,
+        schema: QueryExecutionError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id",
+    alias: "getDataSource",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: DataSourceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "put",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id",
+    alias: "updateDataSource",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Data Source object to update`,
+        type: "Body",
+        schema: DataSourceRequest,
+      },
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: DataSourceResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "delete",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id",
+    alias: "deleteDataSource",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: z.object({}).partial().passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id/tables",
+    alias: "getTables",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: ListViewsResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id/views/sync",
+    alias: "syncTables",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: ListViewsResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/:namespaceId/views/:id",
+    alias: "getView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: ViewResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/:namespaceId/views/:id/versions/:versionId",
+    alias: "getVersionedView",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "namespaceId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+      {
+        name: "versionId",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: ViewResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/namespaces/list",
+    alias: "getNamespaces",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "includeDataSources",
+        type: "Query",
+        schema: z.boolean().optional().default(false),
+      },
+      {
+        name: "includeViews",
+        type: "Query",
+        schema: z.boolean().optional().default(false),
+      },
+    ],
+    response: z
+      .object({ namespaces: z.array(NamespaceResponse) })
+      .passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/tenants",
+    alias: "createTenant",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Tenant request to create with`,
+        type: "Body",
+        schema: TenantRequest,
+      },
+    ],
+    response: TenantResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "get",
+    path: "/v1/tenants/:id",
+    alias: "getTenant",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: TenantResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "put",
+    path: "/v1/tenants/:id",
+    alias: "updateTenant",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `Tenant request to update with`,
+        type: "Body",
+        schema: TenantRequest,
+      },
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: TenantResponse,
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "delete",
+    path: "/v1/tenants/:id",
+    alias: "deleteTenant",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "id",
+        type: "Path",
+        schema: z
+          .string()
+          .regex(
+            /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+          )
+          .uuid(),
+      },
+    ],
+    response: z.object({}).partial().passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+  {
+    method: "post",
+    path: "/v1/views/batch-get",
+    alias: "batchGetViews",
+    requestFormat: "json",
+    parameters: [
+      {
+        name: "body",
+        description: `View ids to get`,
+        type: "Body",
+        schema: ListVersionedViewsRequest,
+      },
+    ],
+    response: z.object({ views: z.array(ViewResponse) }).passthrough(),
+    errors: [
+      {
+        status: NaN,
+        description: `An error related to the user request`,
+        schema: ClientError,
+      },
+    ],
+  },
+]);
+
+export const api = new Zodios(endpoints);
+
+export function createApiClient(baseUrl: string, options?: ZodiosOptions) {
+  return new Zodios(baseUrl, endpoints, options);
+}