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

package/index.ts

@@ -1,180 +1,3390 @@
-/* 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';
-
-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';
-
-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';
+import { makeApi, Zodios } from "@zodios/core";
+import { z } from "zod";
+
+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 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 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 BigQuery = {
+  tunnel: Tunnel;
+  "@type": string;
+  authentication: BigQueryAuthentication;
+};
+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 BigQueryAuthentication = Partial<{
+  projectId: string | null;
+  jsonKeyFile: string | null;
+}>;
+type BranchRequest = {
+  branch: Branch;
+};
+type Branch = {
+  id?: string | undefined;
+  name: string;
+  headId: string;
+};
+type BranchResponse = {
+  branch: Branch;
+  meta: BranchResponseMetadata;
+};
+type BranchResponseMetadata = {
+  diff: Array<ResourceDiff> | null;
+};
+type ResourceDiff =
+  | CreateResourceDiff
+  | DeleteResourceDiff
+  | UpdateResourceDiff;
+type CreateResourceDiff = {
+  "@type": string;
+  resource: Resource;
+};
+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 DeleteResourceDiff = {
+  "@type": string;
+  originalResource: Resource;
+};
+type UpdateResourceDiff = {
+  "@type": string;
+  originalResource: Resource;
+  updatedResource: Resource;
+};
+type CalendarIntervalGrouping = {
+  propertyId: string;
+  targetPropertyId: string | null;
+  "@type": string;
+  calendarInterval: CalendarInterval;
+  targetTimezone?: string | undefined;
+};
+type CalendarInterval = "year" | "month" | "week" | "day" | "hour" | "minute";
+type Clickhouse = {
+  authentication: JdbcAuthentication;
+  database: string;
+  host: string;
+  tunnel: Tunnel;
+  "@type": string;
+  port?: number | undefined;
+  connectionType?: ClickhouseConnectionType | undefined;
+};
+type JdbcAuthentication = PasswordAuthentication;
+type PasswordAuthentication = {
+  "@type": string;
+  username: string;
+  password?: (string | null) | undefined;
+};
+type ClickhouseConnectionType = "HTTP" | "NATIVE";
+type ColumnFormat =
+  | DateTimeColumnFormat
+  | DecimalColumnFormat
+  | DurationColumnFormat;
+type DateTimeColumnFormat = {
+  "@type": string;
+  dateTimeFormatPattern?: DateTimeFormat | undefined;
+  pattern?: (string | null) | undefined;
+  locale: string | null;
+  targetTimezone?: string | undefined;
+};
+type DateTimeFormat = {
+  pattern: string;
+  exportFormat?: string | undefined;
+};
+type DecimalColumnFormat = {
+  "@type": string;
+  decimalFormat: string | null;
+  locale: string | null;
+  unitOfMeasurement?: UnitOfMeasurement | undefined;
+  zeroReplacement: string | null;
+  multiplier: number | null;
+};
+type UnitOfMeasurement = "CURRENCY";
+type DurationColumnFormat = {
+  "@type": string;
+  durationPattern: string | null;
+};
+type CommitResponse = {
+  commit: Commit;
+};
+type Commit = {
+  id?: string | undefined;
+  commitMessage: string;
+  parentId: string | null;
+};
+type Computation = {
+  filter: Filter;
+  properties: Array<Property>;
+  groupings: Array<Grouping>;
+  sorts: Array<Sort>;
+  having: Having;
+  includeRollup?: boolean | undefined;
+};
+type Grouping =
+  | CalendarIntervalGrouping
+  | DatePartGrouping
+  | DecimalIntervalGrouping
+  | IntegerIntervalGrouping
+  | ValueGrouping;
+type DatePartGrouping = {
+  propertyId: string;
+  targetPropertyId: string | null;
+  "@type": string;
+  datePart: DatePart;
+  targetTimezone?: string | undefined;
+};
+type DatePart =
+  | "day-of-week"
+  | "day-of-month"
+  | "month-of-year"
+  | "hour-of-day";
+type DecimalIntervalGrouping = {
+  propertyId: string;
+  targetPropertyId: string | null;
+  "@type": string;
+  interval: number;
+};
+type IntegerIntervalGrouping = {
+  propertyId: string;
+  targetPropertyId: string | null;
+  "@type": string;
+  interval: number;
+};
+type ValueGrouping = {
+  propertyId: string;
+  targetPropertyId: string | null;
+  "@type": string;
+};
+type Sort = {
+  sortDirection: SortDirection;
+  propertyId: string;
+};
+type SortDirection = "asc" | "desc";
+type CreateCommitRequest = {
+  commitMessage: string;
+  parentCommitId: UUID;
+  changes: Array<ResourceChange>;
+};
+type UUID = string;
+type ResourceChange =
+  | CreateResourceChange
+  | UpdateResourceChange
+  | DeleteResourceChange;
+type CreateResourceChange = {
+  "@type": string;
+  resource: Resource;
+};
+type UpdateResourceChange = {
+  "@type": string;
+  resource: Resource;
+};
+type DeleteResourceChange = {
+  "@type": string;
+  id: string;
+};
+type CreateCommitResponse = {
+  commitId: string;
+  changes: Array<ResourceChange>;
+};
+type DataPage = {
+  dataRecords: Array<DataRecord>;
+};
+type DataRecord = {
+  propertyValues: {};
+};
+type DataRequestParameters = Partial<{
+  pagingConfiguration: PagingConfiguration;
+  includeTotalResults: boolean;
+}>;
+type PagingConfiguration = Partial<{
+  perPage: number;
+  page: number;
+}>;
+type DataResponseMetadata = {
+  schema: DataSchema;
+  totalResults: number | null;
+  renderedQuery: string | null;
+};
+type DataSchema = {
+  propertySchema: Array<PropertySchema>;
+};
+type DataSource = {
+  name: string;
+  externalId: string;
+  id?: string | undefined;
+  namespaceId?: string | undefined;
+  configuration: DataSourceConfiguration;
+};
+type DataSourceConfiguration =
+  | Postgres
+  | MySql
+  | MSS
+  | BigQuery
+  | Redshift
+  | Snowflake
+  | Clickhouse;
+type Postgres = {
+  authentication: JdbcAuthentication;
+  database: string;
+  host: string;
+  tunnel: Tunnel;
+  "@type": string;
+  port?: number | undefined;
+};
+type MySql = {
+  authentication: JdbcAuthentication;
+  database: string;
+  host: string;
+  tunnel: Tunnel;
+  "@type": string;
+  port?: number | undefined;
+};
+type MSS = {
+  authentication: JdbcAuthentication;
+  database: string;
+  host: string;
+  tunnel: Tunnel;
+  "@type": string;
+  port?: number | undefined;
+};
+type Redshift = {
+  authentication: JdbcAuthentication;
+  database: string;
+  host: string;
+  tunnel: Tunnel;
+  "@type": string;
+  port?: number | undefined;
+};
+type Snowflake = {
+  tunnel: Tunnel;
+  "@type": string;
+  user: string;
+  account: string;
+  schema: string | null;
+  database: string | null;
+  authentication: SnowflakeAuthentication;
+};
+type SnowflakeAuthentication = SnowflakePasswordAuthentication;
+type SnowflakePasswordAuthentication = {
+  "@type": string;
+  password?: (string | null) | undefined;
+};
+type DataSourceError = QueryExecutionError | QueryTimeoutError;
+type QueryExecutionError = {
+  renderedQuery: string | null;
+  requestTelemetry: RequestTelemetry;
+  message: string | null;
+  "@type": string;
+};
+type RequestTelemetry = {
+  requestTime: string | null;
+  queryTime: string | null;
+  processingTime: string | null;
+  cacheTelemetry?: CacheTelemetry | undefined;
+};
+type CacheTelemetry = {
+  cacheHit: boolean;
+  recordedAt: string | null;
+  ttl: string | null;
+};
+type QueryTimeoutError = {
+  renderedQuery: string | null;
+  requestTelemetry: RequestTelemetry;
+  message: string | null;
+  "@type": string;
+};
+type DataSourceRequest = {
+  dataSource: DataSource;
+};
+type DataSourceResponse = {
+  dataSource: DataSource;
+};
+type DiffBranchResponse = {
+  diff: Array<ResourceDiff>;
+};
+type ExportColumnOptions = {
+  targetPropertyId: string;
+  displayName: string | null;
+  columnFormat: ColumnFormat;
+};
+type ExportTargetConfiguration = {
+  fileName: string | null;
+  exportFormat: ExportFormat;
+  columnDisplayOptions: Array<ExportColumnOptions>;
+};
+type ExportFormat = "CSV" | "TSV" | "XLSX";
+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 Having =
+  | And1
+  | Or1
+  | Not1
+  | Equal1
+  | LateBoundEqual1
+  | In1
+  | LateBoundIn1
+  | LessThan1
+  | LessThanOrEqual1
+  | GreaterThan1
+  | GreaterThanOrEqual1
+  | LateBoundLessThan1
+  | LateBoundLessThanOrEqual1
+  | LateBoundGreaterThan1
+  | LateBoundGreaterThanOrEqual1
+  | Null1
+  | StringContains1
+  | LateBoundStringContains1;
+type ListBranchContentResponse = {
+  content: Resource;
+};
+type ListBranchResponse = {
+  branches: Array<Branch>;
+};
+type ListNamespacesResponse = {
+  namespaces: Array<NamespaceResponse>;
+};
+type NamespaceResponse = {
+  namespace: Namespace;
+  meta: NamespaceResponseMetadata;
+};
+type Namespace = {
+  name: string;
+  ignoreTableList?: Array<string> | undefined;
+  id?: string | undefined;
+};
+type NamespaceResponseMetadata = {
+  dataSources: Array<DataSource> | null;
+  resources: Array<Resource> | null;
+  views: Array<Resource> | null;
+};
+type ListVersionedViewsRequest = {
+  requests: Array<VersionedViewRequest>;
+};
+type VersionedViewRequest = {
+  id: UUID;
+  versionId: UUID;
+};
+type ListViewsResponse = {
+  views: Array<ViewResponse>;
+};
+type ViewResponse = {
+  view: View;
+};
+type View = {
+  name: string;
+  path: string | null;
+  description: string | null;
+  id?: (string | null) | undefined;
+  versionId?: (string | null) | undefined;
+  columnDefinitions: Array<PropertySchema>;
+  namespaceId?: (string | null) | undefined;
+};
+type MergeBranchRequest = {
+  commitMessage: string;
+  sourceBranchId: UUID;
+};
+type NamespaceRequest = {
+  namespace: Namespace;
+};
+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 QueryExecutionResponse = {
+  data: DataPage;
+  meta: DataResponseMetadata;
+  requestTelemetry: RequestTelemetry;
+};
+type QueryExportResponse = QueryExportEmailResponse | QueryExportLinkResponse;
+type QueryExportEmailResponse = {
+  "@type": string;
+};
+type QueryExportLinkResponse = {
+  "@type": string;
+  url: string;
+};
+type QueryPreviewRequest = {
+  query: string;
+  dataRequestParameters: DataRequestParameters;
+  queryContext: {};
+  computation: Computation;
+};
+type Resource = ComputedView | TableView | Folder;
+type SSHTunnel = {
+  "@type": string;
+  tunnel: Tunnel;
+  host: string;
+  port?: number | undefined;
+  authentication: SSHAuthentication;
+};
+type SearchBranchContentResponse = {
+  results: Array<Resource>;
+};
+type TablePreviewRequest = {
+  tableIdentifier: string;
+  dataRequestParameters: DataRequestParameters;
+};
+type Tenant = {
+  id: string;
+  keys?: Array<TenantKey> | undefined;
+  configurationOverrides?: {} | undefined;
+  s3Configuration: TenantS3Configuration;
+};
+type TenantKey = {
+  id: string;
+  createdAt: string;
+  value: string | null;
+};
+type TenantS3Configuration = {
+  prefix: string;
+  bucket: string;
+  region: string;
+  roleArn: string;
+};
+type TenantRequest = {
+  configurationOverrides?: {} | undefined;
+  s3Configuration: TenantS3Configuration;
+};
+type TenantResponse = {
+  tenant: Tenant;
+};
+type TestConnectionRequest = {
+  configuration: DataSourceConfiguration;
+};
+type Tunnel = PublicTunnel | SSHTunnel;
+type ViewExportRequest = {
+  queryContext: {};
+  computation: Computation;
+  exportConfiguration: ExportTargetConfiguration;
+  emailConfiguration: EmailConfiguration;
+};
+type EmailConfiguration = {
+  recipientEmails: Array<string>;
+  subject: string | null;
+  body: string | null;
+};
+type ViewRequest = {
+  view: TableView | ComputedView;
+};
+type ViewResponse1 = {
+  resource: Resource;
+};
+type ViewRunRequest = {
+  dataRequestParameters: DataRequestParameters;
+  requestExecutionParameters: RequestExecutionParameters;
+  queryContext: {};
+  computation: Computation;
+};
+type RequestExecutionParameters = Partial<{
+  forceRefresh: boolean;
+}>;
+
+const Branch: z.ZodType<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.ZodType<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.ZodType<BranchRequest> = z
+  .object({ branch: Branch })
+  .passthrough();
+const PropertyType = z.enum([
+  "boolean",
+  "date",
+  "datetime",
+  "decimal",
+  "double",
+  "integer",
+  "long",
+  "string",
+  "unsupported",
+]);
+const PropertySchema: z.ZodType<PropertySchema> = z
+  .object({
+    array: z.boolean().optional(),
+    id: z.string().regex(/\S/),
+    name: z.string().nullish(),
+    type: PropertyType,
+  })
+  .passthrough();
+const Parameter: z.ZodType<Parameter> = z
+  .object({
+    name: z.string().regex(/\S/),
+    description: z.string().nullable(),
+    required: z.boolean(),
+  })
+  .passthrough();
+const ScheduledEviction: z.ZodType<ScheduledEviction> = z
+  .object({ "@type": z.string(), evictionSchedule: z.string() })
+  .passthrough();
+const TtlEviction: z.ZodType<TtlEviction> = z
+  .object({ "@type": z.string(), ttl: z.string() })
+  .passthrough();
+const EvictionPolicy: z.ZodType<EvictionPolicy> = z.discriminatedUnion(
+  "@type",
+  [ScheduledEviction, TtlEviction]
+);
+const ComputedView: z.ZodType<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.ZodType<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.ZodType<CreateResourceDiff> = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const DeleteResourceDiff: z.ZodType<DeleteResourceDiff> = z
+  .object({ "@type": z.string(), originalResource: Resource })
+  .passthrough();
+const UpdateResourceDiff: z.ZodType<UpdateResourceDiff> = z
+  .object({
+    "@type": z.string(),
+    originalResource: Resource,
+    updatedResource: Resource,
+  })
+  .passthrough();
+const ResourceDiff: z.ZodType<ResourceDiff> = z.discriminatedUnion("@type", [
+  CreateResourceDiff,
+  DeleteResourceDiff,
+  UpdateResourceDiff,
+]);
+const BranchResponseMetadata: z.ZodType<BranchResponseMetadata> = z
+  .object({ diff: z.array(ResourceDiff).nullable() })
+  .passthrough();
+const BranchResponse: z.ZodType<BranchResponse> = z
+  .object({ branch: Branch, meta: BranchResponseMetadata.nullable() })
+  .passthrough();
+const DiffBranchResponse: z.ZodType<DiffBranchResponse> = z
+  .object({ diff: z.array(ResourceDiff) })
+  .passthrough();
+const UUID = z.string();
+const CreateResourceChange: z.ZodType<CreateResourceChange> = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const UpdateResourceChange: z.ZodType<UpdateResourceChange> = z
+  .object({ "@type": z.string(), resource: Resource })
+  .passthrough();
+const DeleteResourceChange: z.ZodType<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.ZodType<ResourceChange> = z.discriminatedUnion(
+  "@type",
+  [CreateResourceChange, UpdateResourceChange, DeleteResourceChange]
+);
+const CreateCommitRequest: z.ZodType<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.ZodType<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.ZodType<ListBranchContentResponse> = z
+  .object({ content: Resource })
+  .passthrough();
+const MergeBranchRequest: z.ZodType<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.ZodType<PasswordAuthentication> = z
+  .object({
+    "@type": z.string(),
+    username: z.string().regex(/\S/),
+    password: z.string().nullish(),
+  })
+  .passthrough();
+const JdbcAuthentication: z.ZodType<JdbcAuthentication> =
+  PasswordAuthentication;
+const PublicTunnel: z.ZodType<PublicTunnel> = z
+  .object({ "@type": z.string() })
+  .passthrough();
+const VendorPrivateKeyAuthentication: z.ZodType<VendorPrivateKeyAuthentication> =
+  z
+    .object({ username: z.string().regex(/\S/), "@type": z.string() })
+    .passthrough();
+const TenantPrivateKeyAuthentication: z.ZodType<TenantPrivateKeyAuthentication> =
+  z
+    .object({
+      username: z.string().regex(/\S/),
+      "@type": z.string(),
+      privateKey: z.string().nullish(),
+    })
+    .passthrough();
+const SSHAuthentication: z.ZodType<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.ZodType<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.ZodType<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.ZodType<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.ZodType<BigQueryAuthentication> = z
+  .object({
+    projectId: z.string().nullable(),
+    jsonKeyFile: z.string().nullable(),
+  })
+  .partial()
+  .passthrough();
+const BigQuery: z.ZodType<BigQuery> = z
+  .object({
+    tunnel: Tunnel,
+    "@type": z.string(),
+    authentication: BigQueryAuthentication,
+  })
+  .passthrough();
+const Redshift: z.ZodType<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.ZodType<SnowflakePasswordAuthentication> =
+  z
+    .object({ "@type": z.string(), password: z.string().nullish() })
+    .passthrough();
+const SnowflakeAuthentication: z.ZodType<SnowflakeAuthentication> =
+  SnowflakePasswordAuthentication;
+const Snowflake: z.ZodType<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.ZodType<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.ZodType<DataSourceConfiguration> =
+  z.discriminatedUnion("@type", [
+    Postgres,
+    MySql,
+    MSS,
+    BigQuery,
+    Redshift,
+    Snowflake,
+    Clickhouse,
+  ]);
+const TestConnectionRequest: z.ZodType<TestConnectionRequest> = z
+  .object({ configuration: DataSourceConfiguration })
+  .passthrough();
+const Namespace: z.ZodType<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.ZodType<NamespaceRequest> = z
+  .object({ namespace: Namespace })
+  .passthrough();
+const DataSource: z.ZodType<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.ZodType<NamespaceResponseMetadata> = z
+  .object({
+    dataSources: z.array(DataSource).nullable(),
+    resources: z.array(Resource).nullable(),
+    views: z.array(Resource).nullable(),
+  })
+  .passthrough();
+const NamespaceResponse: z.ZodType<NamespaceResponse> = z
+  .object({ namespace: Namespace, meta: NamespaceResponseMetadata.nullable() })
+  .passthrough();
+const DataSourceRequest: z.ZodType<DataSourceRequest> = z
+  .object({ dataSource: DataSource })
+  .passthrough();
+const DataSourceResponse: z.ZodType<DataSourceResponse> = z
+  .object({ dataSource: DataSource })
+  .passthrough();
+const PagingConfiguration: z.ZodType<PagingConfiguration> = z
+  .object({ perPage: z.number().int().gte(1), page: z.number().int().gte(0) })
+  .partial()
+  .passthrough();
+const DataRequestParameters: z.ZodType<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.ZodType<BooleanPropertyValue> = z
+  .object({ "@type": z.string(), value: z.boolean() })
+  .passthrough();
+const DatePropertyValue: z.ZodType<DatePropertyValue> = z
+  .object({ "@type": z.string(), value: z.string() })
+  .passthrough();
+const DateTimePropertyValue: z.ZodType<DateTimePropertyValue> = z
+  .object({ "@type": z.string(), value: z.string().datetime({ offset: true }) })
+  .passthrough();
+const DecimalPropertyValue: z.ZodType<DecimalPropertyValue> = z
+  .object({ "@type": z.string(), value: z.number() })
+  .passthrough();
+const DoublePropertyValue: z.ZodType<DoublePropertyValue> = z
+  .object({ "@type": z.string(), value: z.number() })
+  .passthrough();
+const IntegerPropertyValue: z.ZodType<IntegerPropertyValue> = z
+  .object({ "@type": z.string(), value: z.number().int() })
+  .passthrough();
+const StringPropertyValue: z.ZodType<StringPropertyValue> = z
+  .object({ "@type": z.string(), value: z.string() })
+  .passthrough();
+const PropertyValue: z.ZodType<PropertyValue> = z.discriminatedUnion("@type", [
+  BooleanPropertyValue,
+  DatePropertyValue,
+  DateTimePropertyValue,
+  DecimalPropertyValue,
+  DoublePropertyValue,
+  IntegerPropertyValue,
+  StringPropertyValue,
+]);
+const Equal: z.ZodType<Equal> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LateBoundEqual: z.ZodType<LateBoundEqual> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const In: z.ZodType<In> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    values: z.array(PropertyValue),
+  })
+  .passthrough();
+const LateBoundIn: z.ZodType<LateBoundIn> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LessThan: z.ZodType<LessThan> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LessThanOrEqual: z.ZodType<LessThanOrEqual> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const GreaterThan: z.ZodType<GreaterThan> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const GreaterThanOrEqual: z.ZodType<GreaterThanOrEqual> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: PropertyValue,
+  })
+  .passthrough();
+const LateBoundLessThan: z.ZodType<LateBoundLessThan> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundLessThanOrEqual: z.ZodType<LateBoundLessThanOrEqual> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThan: z.ZodType<LateBoundGreaterThan> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThanOrEqual: z.ZodType<LateBoundGreaterThanOrEqual> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const Null: z.ZodType<Null> = z
+  .object({ "@type": z.string(), propertyId: z.string().regex(/\S/) })
+  .passthrough();
+const StringContains: z.ZodType<StringContains> = z
+  .object({
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+    value: StringPropertyValue,
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const LateBoundStringContains: z.ZodType<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.ZodType<AggregationOption> = z
+  .object({ decimalValue: z.number() })
+  .passthrough();
+const AggregateProperty: z.ZodType<AggregateProperty> = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    propertyId: z.string().nullable(),
+    aggregation: Aggregation,
+    aggregationOption: AggregationOption.nullish(),
+  })
+  .passthrough();
+const SourceProperty: z.ZodType<SourceProperty> = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    propertyId: z.string().regex(/\S/),
+  })
+  .passthrough();
+const FormulaProperty: z.ZodType<FormulaProperty> = z
+  .object({
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    formula: z.string(),
+  })
+  .passthrough();
+const Property: z.ZodType<Property> = z.discriminatedUnion("@type", [
+  AggregateProperty,
+  SourceProperty,
+  FormulaProperty,
+]);
+const CalendarInterval = z.enum([
+  "year",
+  "month",
+  "week",
+  "day",
+  "hour",
+  "minute",
+]);
+const CalendarIntervalGrouping: z.ZodType<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.ZodType<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.ZodType<DecimalIntervalGrouping> = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+    interval: z.number().gt(0),
+  })
+  .passthrough();
+const IntegerIntervalGrouping: z.ZodType<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.ZodType<ValueGrouping> = z
+  .object({
+    propertyId: z.string().regex(/\S/),
+    targetPropertyId: z.string().nullable(),
+    "@type": z.string(),
+  })
+  .passthrough();
+const Grouping: z.ZodType<Grouping> = z.discriminatedUnion("@type", [
+  CalendarIntervalGrouping,
+  DatePartGrouping,
+  DecimalIntervalGrouping,
+  IntegerIntervalGrouping,
+  ValueGrouping,
+]);
+const SortDirection = z.enum(["asc", "desc"]);
+const Sort: z.ZodType<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.ZodType<Equal1> = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LateBoundEqual1: z.ZodType<LateBoundEqual1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const In1: z.ZodType<In1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    values: z.array(PropertyValue),
+  })
+  .passthrough();
+const LateBoundIn1: z.ZodType<LateBoundIn1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LessThan1: z.ZodType<LessThan1> = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LessThanOrEqual1: z.ZodType<LessThanOrEqual1> = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const GreaterThan1: z.ZodType<GreaterThan1> = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const GreaterThanOrEqual1: z.ZodType<GreaterThanOrEqual1> = z
+  .object({ "@type": z.string(), property: Property, value: PropertyValue })
+  .passthrough();
+const LateBoundLessThan1: z.ZodType<LateBoundLessThan1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundLessThanOrEqual1: z.ZodType<LateBoundLessThanOrEqual1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThan1: z.ZodType<LateBoundGreaterThan1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const LateBoundGreaterThanOrEqual1: z.ZodType<LateBoundGreaterThanOrEqual1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    valueVariableReference: z.string().regex(/\S/),
+  })
+  .passthrough();
+const Null1: z.ZodType<Null1> = z
+  .object({ "@type": z.string(), property: Property })
+  .passthrough();
+const StringContains1: z.ZodType<StringContains1> = z
+  .object({
+    "@type": z.string(),
+    property: Property,
+    value: StringPropertyValue,
+    caseInsensitive: z.boolean(),
+  })
+  .passthrough();
+const LateBoundStringContains1: z.ZodType<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.ZodType<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.ZodType<QueryPreviewRequest> = z
+  .object({
+    query: z.string().regex(/\S/),
+    dataRequestParameters: DataRequestParameters,
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+  })
+  .passthrough();
+const DataRecord: z.ZodType<DataRecord> = z
+  .object({ propertyValues: z.record(z.array(PropertyValue)) })
+  .passthrough();
+const DataPage: z.ZodType<DataPage> = z
+  .object({ dataRecords: z.array(DataRecord) })
+  .passthrough();
+const DataSchema: z.ZodType<DataSchema> = z
+  .object({ propertySchema: z.array(PropertySchema) })
+  .passthrough();
+const DataResponseMetadata: z.ZodType<DataResponseMetadata> = z
+  .object({
+    schema: DataSchema,
+    totalResults: z.number().int().nullable(),
+    renderedQuery: z.string().nullable(),
+  })
+  .passthrough();
+const CacheTelemetry: z.ZodType<CacheTelemetry> = z
+  .object({
+    cacheHit: z.boolean(),
+    recordedAt: z.string().datetime({ offset: true }).nullable(),
+    ttl: z.string().nullable(),
+  })
+  .passthrough();
+const RequestTelemetry: z.ZodType<RequestTelemetry> = z
+  .object({
+    requestTime: z.string().nullable(),
+    queryTime: z.string().nullable(),
+    processingTime: z.string().nullable(),
+    cacheTelemetry: CacheTelemetry.nullish(),
+  })
+  .passthrough();
+const QueryExecutionResponse: z.ZodType<QueryExecutionResponse> = z
+  .object({
+    data: DataPage,
+    meta: DataResponseMetadata,
+    requestTelemetry: RequestTelemetry.nullable(),
+  })
+  .passthrough();
+const QueryExecutionError: z.ZodType<QueryExecutionError> = z
+  .object({
+    renderedQuery: z.string().nullable(),
+    requestTelemetry: RequestTelemetry.nullable(),
+    message: z.string().nullable(),
+    "@type": z.string(),
+  })
+  .passthrough();
+const TablePreviewRequest: z.ZodType<TablePreviewRequest> = z
+  .object({
+    tableIdentifier: z.string().regex(/\S/),
+    dataRequestParameters: DataRequestParameters,
+  })
+  .passthrough();
+const ExportFormat = z.enum(["CSV", "TSV", "XLSX"]);
+const DateTimeFormat: z.ZodType<DateTimeFormat> = z
+  .object({ pattern: z.string(), exportFormat: z.string().optional() })
+  .passthrough();
+const DateTimeColumnFormat: z.ZodType<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.ZodType<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.ZodType<DurationColumnFormat> = z
+  .object({ "@type": z.string(), durationPattern: z.string().nullable() })
+  .passthrough();
+const ColumnFormat: z.ZodType<ColumnFormat> = z.discriminatedUnion("@type", [
+  DateTimeColumnFormat,
+  DecimalColumnFormat,
+  DurationColumnFormat,
+]);
+const ExportColumnOptions: z.ZodType<ExportColumnOptions> = z
+  .object({
+    targetPropertyId: z.string(),
+    displayName: z.string().nullable(),
+    columnFormat: ColumnFormat.nullable(),
+  })
+  .passthrough();
+const ExportTargetConfiguration: z.ZodType<ExportTargetConfiguration> = z
+  .object({
+    fileName: z.string().nullable(),
+    exportFormat: ExportFormat,
+    columnDisplayOptions: z.array(ExportColumnOptions),
+  })
+  .passthrough();
+const EmailConfiguration: z.ZodType<EmailConfiguration> = z
+  .object({
+    recipientEmails: z.array(z.string()).min(1),
+    subject: z.string().nullable(),
+    body: z.string().nullable(),
+  })
+  .passthrough();
+const ViewExportRequest: z.ZodType<ViewExportRequest> = z
+  .object({
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+    exportConfiguration: ExportTargetConfiguration,
+    emailConfiguration: EmailConfiguration.nullable(),
+  })
+  .passthrough();
+const QueryExportEmailResponse: z.ZodType<QueryExportEmailResponse> = z
+  .object({ "@type": z.string() })
+  .passthrough();
+const QueryExportLinkResponse: z.ZodType<QueryExportLinkResponse> = z
+  .object({ "@type": z.string(), url: z.string().regex(/\S/) })
+  .passthrough();
+const QueryExportResponse: z.ZodType<QueryExportResponse> =
+  z.discriminatedUnion("@type", [
+    QueryExportEmailResponse,
+    QueryExportLinkResponse,
+  ]);
+const RequestExecutionParameters: z.ZodType<RequestExecutionParameters> = z
+  .object({ forceRefresh: z.boolean() })
+  .partial()
+  .passthrough();
+const ViewRunRequest: z.ZodType<ViewRunRequest> = z
+  .object({
+    dataRequestParameters: DataRequestParameters,
+    requestExecutionParameters: RequestExecutionParameters.nullable(),
+    queryContext: z.object({}).partial().passthrough(),
+    computation: Computation.nullable(),
+  })
+  .passthrough();
+const View: z.ZodType<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.ZodType<ViewResponse> = z
+  .object({ view: View })
+  .passthrough();
+const ListViewsResponse: z.ZodType<ListViewsResponse> = z
+  .object({ views: z.array(ViewResponse) })
+  .passthrough();
+const TenantS3Configuration: z.ZodType<TenantS3Configuration> = z
+  .object({
+    prefix: z.string(),
+    bucket: z.string(),
+    region: z.string(),
+    roleArn: z.string(),
+  })
+  .passthrough();
+const TenantRequest: z.ZodType<TenantRequest> = z
+  .object({
+    configurationOverrides: z.record(z.string()).optional(),
+    s3Configuration: TenantS3Configuration.nullable(),
+  })
+  .passthrough();
+const TenantKey: z.ZodType<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.ZodType<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.ZodType<TenantResponse> = z
+  .object({ tenant: Tenant })
+  .passthrough();
+const VersionedViewRequest: z.ZodType<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.ZodType<ListVersionedViewsRequest> = z
+  .object({ requests: z.array(VersionedViewRequest) })
+  .passthrough();
+const Commit: z.ZodType<Commit> = 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(),
+    commitMessage: z.string().max(200).regex(/\S/),
+    parentId: 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()
+      .nullable(),
+  })
+  .passthrough();
+const CommitResponse: z.ZodType<CommitResponse> = z
+  .object({ commit: Commit })
+  .passthrough();
+const QueryTimeoutError: z.ZodType<QueryTimeoutError> = z
+  .object({
+    renderedQuery: z.string().nullable(),
+    requestTelemetry: RequestTelemetry.nullable(),
+    message: z.string().nullable(),
+    "@type": z.string(),
+  })
+  .passthrough();
+const DataSourceError: z.ZodType<DataSourceError> = z.discriminatedUnion(
+  "@type",
+  [QueryExecutionError, QueryTimeoutError]
+);
+const ListNamespacesResponse: z.ZodType<ListNamespacesResponse> = z
+  .object({ namespaces: z.array(NamespaceResponse) })
+  .passthrough();
+const ListViewsRequest = z
+  .object({
+    viewIds: z.array(
+      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 SearchBranchContentResponse: z.ZodType<SearchBranchContentResponse> = z
+  .object({ results: z.array(Resource) })
+  .passthrough();
+const TestConnectionResponse = z
+  .object({ numberOfTables: z.number().int().gte(0) })
+  .passthrough();
+const ViewRequest: z.ZodType<ViewRequest> = z
+  .object({ view: z.discriminatedUnion("@type", [TableView, ComputedView]) })
+  .passthrough();
+const ViewResponse1: z.ZodType<ViewResponse1> = z
+  .object({ resource: Resource })
+  .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,
+  Commit,
+  CommitResponse,
+  QueryTimeoutError,
+  DataSourceError,
+  ListNamespacesResponse,
+  ListViewsRequest,
+  SearchBranchContentResponse,
+  TestConnectionResponse,
+  ViewRequest,
+  ViewResponse1,
+};
+
+const Branch_ResourceEndpoints = 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: "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: "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: "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,
+      },
+    ],
+  },
+]);
+
+export const Branch_ResourceApi = new Zodios(Branch_ResourceEndpoints);
+
+const Commit_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const Commit_ResourceApi = new Zodios(Commit_ResourceEndpoints);
+
+const Branch_Content_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const Branch_Content_ResourceApi = new Zodios(
+  Branch_Content_ResourceEndpoints
+);
+
+const Test_Connection_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const Test_Connection_ResourceApi = new Zodios(
+  Test_Connection_ResourceEndpoints
+);
+
+const Health_ResourceEndpoints = makeApi([
+  {
+    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(),
+  },
+]);
+
+export const Health_ResourceApi = new Zodios(Health_ResourceEndpoints);
+
+const Namespace_ResourceEndpoints = makeApi([
+  {
+    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/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: "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,
+      },
+    ],
+  },
+]);
+
+export const Namespace_ResourceApi = new Zodios(Namespace_ResourceEndpoints);
+
+const Data_Source_ResourceEndpoints = makeApi([
+  {
+    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: "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,
+      },
+    ],
+  },
+]);
+
+export const Data_Source_ResourceApi = new Zodios(
+  Data_Source_ResourceEndpoints
+);
+
+const Query_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const Query_ResourceApi = new Zodios(Query_ResourceEndpoints);
+
+const View_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const View_ResourceApi = new Zodios(View_ResourceEndpoints);
+
+const Tenant_ResourceEndpoints = makeApi([
+  {
+    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,
+      },
+    ],
+  },
+]);
+
+export const Tenant_ResourceApi = new Zodios(Tenant_ResourceEndpoints);
+
+const List_Views_ResourceEndpoints = makeApi([
+  {
+    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 List_Views_ResourceApi = new Zodios(List_Views_ResourceEndpoints);
+
+export function createApiClient(baseUrl: string, options?: ZodiosOptions) {
+  return new Zodios(baseUrl, endpoints, options);
+}