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

package/index.ts

@@ -1,6 +1,24 @@
-import { makeApi, Zodios, type ZodiosOptions } from "@zodios/core";
+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>;
@@ -127,24 +145,6 @@ type Equal1 = {
   value: PropertyValue;
 };
 type Property = AggregateProperty | SourceProperty | FormulaProperty;
-type AggregateProperty = {
-  targetPropertyId: string | null;
-  "@type": string;
-  propertyId: string | null;
-  aggregation: Aggregation;
-  aggregationOption?: AggregationOption | undefined;
-};
-type Aggregation =
-  | "avg"
-  | "count"
-  | "count-distinct"
-  | "max"
-  | "min"
-  | "percentile"
-  | "sum";
-type AggregationOption = {
-  decimalValue: number;
-};
 type SourceProperty = {
   targetPropertyId: string | null;
   "@type": string;
@@ -226,33 +226,52 @@ type LateBoundStringContains1 = {
   valueVariableReference: string;
   caseInsensitive: boolean;
 };
-type Filter =
-  | And
-  | Or
-  | Not
-  | Equal
-  | LateBoundEqual
-  | In
-  | LateBoundIn
-  | LessThan
-  | LessThanOrEqual
-  | GreaterThan
-  | GreaterThanOrEqual
-  | LateBoundLessThan
-  | LateBoundLessThanOrEqual
-  | LateBoundGreaterThan
-  | LateBoundGreaterThanOrEqual
-  | Null
-  | StringContains
-  | LateBoundStringContains;
-type Folder = {
+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;
-  path: string | null;
-  description: string | null;
-  id?: (string | null) | undefined;
-  versionId?: (string | null) | undefined;
+  headId: string;
+};
+type BranchResponse = {
+  branch: Branch;
+  meta: BranchResponseMetadata;
+};
+type BranchResponseMetadata = {
+  diff: Array<ResourceDiff> | null;
+};
+type ResourceDiff =
+  | CreateResourceDiff
+  | DeleteResourceDiff
+  | UpdateResourceDiff;
+type CreateResourceDiff = {
   "@type": string;
-  children: Array<Resource> | null;
+  resource: Resource;
 };
 type ComputedView = {
   columnDefinitions: Array<PropertySchema>;
@@ -310,6 +329,304 @@ type TableView = {
   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
@@ -329,6 +646,58 @@ type Having =
   | 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;
@@ -345,6 +714,25 @@ 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;
@@ -353,26 +741,71 @@ type SSHTunnel = {
   port?: number | undefined;
   authentication: SSHAuthentication;
 };
-type PublicTunnel = {
-  "@type": string;
+type SearchBranchContentResponse = {
+  results: Array<Resource>;
 };
-type SSHAuthentication =
-  | VendorPrivateKeyAuthentication
-  | TenantPrivateKeyAuthentication;
-type VendorPrivateKeyAuthentication = {
-  username: string;
-  "@type": string;
+type TablePreviewRequest = {
+  tableIdentifier: string;
+  dataRequestParameters: DataRequestParameters;
 };
-type TenantPrivateKeyAuthentication = {
-  username: string;
-  "@type": string;
-  privateKey?: (string | null) | undefined;
+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;
-
-const Branch = z
-  .object({
-    id: z
+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}/
@@ -391,7 +824,7 @@ const Branch = z
       .uuid(),
   })
   .passthrough();
-const ListBranchResponse = z
+const ListBranchResponse: z.ZodType<ListBranchResponse> = z
   .object({ branches: z.array(Branch) })
   .passthrough();
 const ClientError = z
@@ -400,7 +833,9 @@ const ClientError = z
     message: z.string().regex(/\S/),
   })
   .passthrough();
-const BranchRequest = z.object({ branch: Branch }).passthrough();
+const BranchRequest: z.ZodType<BranchRequest> = z
+  .object({ branch: Branch })
+  .passthrough();
 const PropertyType = z.enum([
   "boolean",
   "date",
@@ -412,7 +847,7 @@ const PropertyType = z.enum([
   "string",
   "unsupported",
 ]);
-const PropertySchema = z
+const PropertySchema: z.ZodType<PropertySchema> = z
   .object({
     array: z.boolean().optional(),
     id: z.string().regex(/\S/),
@@ -420,24 +855,24 @@ const PropertySchema = z
     type: PropertyType,
   })
   .passthrough();
-const Parameter = z
+const Parameter: z.ZodType<Parameter> = z
   .object({
     name: z.string().regex(/\S/),
     description: z.string().nullable(),
     required: z.boolean(),
   })
   .passthrough();
-const ScheduledEviction = z
+const ScheduledEviction: z.ZodType<ScheduledEviction> = z
   .object({ "@type": z.string(), evictionSchedule: z.string() })
   .passthrough();
-const TtlEviction = z
+const TtlEviction: z.ZodType<TtlEviction> = z
   .object({ "@type": z.string(), ttl: z.string() })
   .passthrough();
-const EvictionPolicy = z.discriminatedUnion("@type", [
-  ScheduledEviction,
-  TtlEviction,
-]);
-const ComputedView = z
+const EvictionPolicy: z.ZodType<EvictionPolicy> = z.discriminatedUnion(
+  "@type",
+  [ScheduledEviction, TtlEviction]
+);
+const ComputedView: z.ZodType<ComputedView> = z
   .object({
     columnDefinitions: z.array(PropertySchema),
     namespaceId: z
@@ -471,7 +906,7 @@ const ComputedView = z
     cacheEvictionPolicy: EvictionPolicy.nullable(),
   })
   .passthrough();
-const TableView = z
+const TableView: z.ZodType<TableView> = z
   .object({
     columnDefinitions: z.array(PropertySchema),
     namespaceId: z
@@ -531,41 +966,41 @@ const Folder: z.ZodType<Folder> = z.lazy(() =>
 const Resource: z.ZodType<Resource> = z.lazy(() =>
   z.discriminatedUnion("@type", [ComputedView, TableView, Folder])
 );
-const CreateResourceDiff = z
+const CreateResourceDiff: z.ZodType<CreateResourceDiff> = z
   .object({ "@type": z.string(), resource: Resource })
   .passthrough();
-const DeleteResourceDiff = z
+const DeleteResourceDiff: z.ZodType<DeleteResourceDiff> = z
   .object({ "@type": z.string(), originalResource: Resource })
   .passthrough();
-const UpdateResourceDiff = z
+const UpdateResourceDiff: z.ZodType<UpdateResourceDiff> = z
   .object({
     "@type": z.string(),
     originalResource: Resource,
     updatedResource: Resource,
   })
   .passthrough();
-const ResourceDiff = z.discriminatedUnion("@type", [
+const ResourceDiff: z.ZodType<ResourceDiff> = z.discriminatedUnion("@type", [
   CreateResourceDiff,
   DeleteResourceDiff,
   UpdateResourceDiff,
 ]);
-const BranchResponseMetadata = z
+const BranchResponseMetadata: z.ZodType<BranchResponseMetadata> = z
   .object({ diff: z.array(ResourceDiff).nullable() })
   .passthrough();
-const BranchResponse = z
+const BranchResponse: z.ZodType<BranchResponse> = z
   .object({ branch: Branch, meta: BranchResponseMetadata.nullable() })
   .passthrough();
-const DiffBranchResponse = z
+const DiffBranchResponse: z.ZodType<DiffBranchResponse> = z
   .object({ diff: z.array(ResourceDiff) })
   .passthrough();
 const UUID = z.string();
-const CreateResourceChange = z
+const CreateResourceChange: z.ZodType<CreateResourceChange> = z
   .object({ "@type": z.string(), resource: Resource })
   .passthrough();
-const UpdateResourceChange = z
+const UpdateResourceChange: z.ZodType<UpdateResourceChange> = z
   .object({ "@type": z.string(), resource: Resource })
   .passthrough();
-const DeleteResourceChange = z
+const DeleteResourceChange: z.ZodType<DeleteResourceChange> = z
   .object({
     "@type": z.string(),
     id: z
@@ -576,12 +1011,11 @@ const DeleteResourceChange = z
       .uuid(),
   })
   .passthrough();
-const ResourceChange = z.discriminatedUnion("@type", [
-  CreateResourceChange,
-  UpdateResourceChange,
-  DeleteResourceChange,
-]);
-const CreateCommitRequest = z
+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(
@@ -590,7 +1024,7 @@ const CreateCommitRequest = z
     changes: z.array(ResourceChange),
   })
   .passthrough();
-const CreateCommitResponse = z
+const CreateCommitResponse: z.ZodType<CreateCommitResponse> = z
   .object({
     commitId: z
       .string()
@@ -601,8 +1035,10 @@ const CreateCommitResponse = z
     changes: z.array(ResourceChange),
   })
   .passthrough();
-const ListBranchContentResponse = z.object({ content: Resource }).passthrough();
-const MergeBranchRequest = z
+const ListBranchContentResponse: z.ZodType<ListBranchContentResponse> = z
+  .object({ content: Resource })
+  .passthrough();
+const MergeBranchRequest: z.ZodType<MergeBranchRequest> = z
   .object({
     commitMessage: z.string(),
     sourceBranchId: UUID.regex(
@@ -610,29 +1046,34 @@ const MergeBranchRequest = z
     ).uuid(),
   })
   .passthrough();
-const PasswordAuthentication = z
+const PasswordAuthentication: z.ZodType<PasswordAuthentication> = z
   .object({
     "@type": z.string(),
     username: z.string().regex(/\S/),
     password: z.string().nullish(),
   })
   .passthrough();
-const JdbcAuthentication = PasswordAuthentication;
-const PublicTunnel = z.object({ "@type": z.string() }).passthrough();
-const VendorPrivateKeyAuthentication = z
-  .object({ username: z.string().regex(/\S/), "@type": z.string() })
-  .passthrough();
-const TenantPrivateKeyAuthentication = z
-  .object({
-    username: z.string().regex(/\S/),
-    "@type": z.string(),
-    privateKey: z.string().nullish(),
-  })
+const JdbcAuthentication: z.ZodType<JdbcAuthentication> =
+  PasswordAuthentication;
+const PublicTunnel: z.ZodType<PublicTunnel> = z
+  .object({ "@type": z.string() })
   .passthrough();
-const SSHAuthentication = z.discriminatedUnion("@type", [
-  VendorPrivateKeyAuthentication,
-  TenantPrivateKeyAuthentication,
-]);
+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({
@@ -647,7 +1088,7 @@ const SSHTunnel: z.ZodType<SSHTunnel> = z.lazy(() =>
 const Tunnel: z.ZodType<Tunnel> = z.lazy(() =>
   z.discriminatedUnion("@type", [PublicTunnel, SSHTunnel])
 );
-const Postgres = z
+const Postgres: z.ZodType<Postgres> = z
   .object({
     authentication: JdbcAuthentication,
     database: z.string().regex(/\S/),
@@ -657,7 +1098,7 @@ const Postgres = z
     port: z.number().int().optional(),
   })
   .passthrough();
-const MySql = z
+const MySql: z.ZodType<MySql> = z
   .object({
     authentication: JdbcAuthentication,
     database: z.string().regex(/\S/),
@@ -667,7 +1108,7 @@ const MySql = z
     port: z.number().int().optional(),
   })
   .passthrough();
-const MSS = z
+const MSS: z.ZodType<MSS> = z
   .object({
     authentication: JdbcAuthentication,
     database: z.string().regex(/\S/),
@@ -677,21 +1118,21 @@ const MSS = z
     port: z.number().int().optional(),
   })
   .passthrough();
-const BigQueryAuthentication = z
+const BigQueryAuthentication: z.ZodType<BigQueryAuthentication> = z
   .object({
     projectId: z.string().nullable(),
     jsonKeyFile: z.string().nullable(),
   })
   .partial()
   .passthrough();
-const BigQuery = z
+const BigQuery: z.ZodType<BigQuery> = z
   .object({
     tunnel: Tunnel,
     "@type": z.string(),
     authentication: BigQueryAuthentication,
   })
   .passthrough();
-const Redshift = z
+const Redshift: z.ZodType<Redshift> = z
   .object({
     authentication: JdbcAuthentication,
     database: z.string().regex(/\S/),
@@ -701,11 +1142,13 @@ const Redshift = z
     port: z.number().int().optional(),
   })
   .passthrough();
-const SnowflakePasswordAuthentication = z
-  .object({ "@type": z.string(), password: z.string().nullish() })
-  .passthrough();
-const SnowflakeAuthentication = SnowflakePasswordAuthentication;
-const Snowflake = z
+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(),
@@ -717,7 +1160,7 @@ const Snowflake = z
   })
   .passthrough();
 const ClickhouseConnectionType = z.enum(["HTTP", "NATIVE"]);
-const Clickhouse = z
+const Clickhouse: z.ZodType<Clickhouse> = z
   .object({
     authentication: JdbcAuthentication,
     database: z.string().regex(/\S/),
@@ -728,19 +1171,20 @@ const Clickhouse = z
     connectionType: ClickhouseConnectionType.optional(),
   })
   .passthrough();
-const DataSourceConfiguration = z.discriminatedUnion("@type", [
-  Postgres,
-  MySql,
-  MSS,
-  BigQuery,
-  Redshift,
-  Snowflake,
-  Clickhouse,
-]);
-const TestConnectionRequest = z
+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
+const Namespace: z.ZodType<Namespace> = z
   .object({
     name: z.string().max(200).regex(/\S/),
     ignoreTableList: z.array(z.string()).optional(),
@@ -753,8 +1197,10 @@ const Namespace = z
       .optional(),
   })
   .passthrough();
-const NamespaceRequest = z.object({ namespace: Namespace }).passthrough();
-const DataSource = z
+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/),
@@ -775,23 +1221,27 @@ const DataSource = z
     configuration: DataSourceConfiguration,
   })
   .passthrough();
-const NamespaceResponseMetadata = z
+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
+const NamespaceResponse: z.ZodType<NamespaceResponse> = z
   .object({ namespace: Namespace, meta: NamespaceResponseMetadata.nullable() })
   .passthrough();
-const DataSourceRequest = z.object({ dataSource: DataSource }).passthrough();
-const DataSourceResponse = z.object({ dataSource: DataSource }).passthrough();
-const PagingConfiguration = z
+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
+const DataRequestParameters: z.ZodType<DataRequestParameters> = z
   .object({
     pagingConfiguration: PagingConfiguration,
     includeTotalResults: z.boolean(),
@@ -811,28 +1261,28 @@ const Or: z.ZodType<Or> = z.lazy(() =>
 const Not: z.ZodType<Not> = z.lazy(() =>
   z.object({ "@type": z.string(), value: Filter }).passthrough()
 );
-const BooleanPropertyValue = z
+const BooleanPropertyValue: z.ZodType<BooleanPropertyValue> = z
   .object({ "@type": z.string(), value: z.boolean() })
   .passthrough();
-const DatePropertyValue = z
+const DatePropertyValue: z.ZodType<DatePropertyValue> = z
   .object({ "@type": z.string(), value: z.string() })
   .passthrough();
-const DateTimePropertyValue = z
+const DateTimePropertyValue: z.ZodType<DateTimePropertyValue> = z
   .object({ "@type": z.string(), value: z.string().datetime({ offset: true }) })
   .passthrough();
-const DecimalPropertyValue = z
+const DecimalPropertyValue: z.ZodType<DecimalPropertyValue> = z
   .object({ "@type": z.string(), value: z.number() })
   .passthrough();
-const DoublePropertyValue = z
+const DoublePropertyValue: z.ZodType<DoublePropertyValue> = z
   .object({ "@type": z.string(), value: z.number() })
   .passthrough();
-const IntegerPropertyValue = z
+const IntegerPropertyValue: z.ZodType<IntegerPropertyValue> = z
   .object({ "@type": z.string(), value: z.number().int() })
   .passthrough();
-const StringPropertyValue = z
+const StringPropertyValue: z.ZodType<StringPropertyValue> = z
   .object({ "@type": z.string(), value: z.string() })
   .passthrough();
-const PropertyValue = z.discriminatedUnion("@type", [
+const PropertyValue: z.ZodType<PropertyValue> = z.discriminatedUnion("@type", [
   BooleanPropertyValue,
   DatePropertyValue,
   DateTimePropertyValue,
@@ -841,94 +1291,94 @@ const PropertyValue = z.discriminatedUnion("@type", [
   IntegerPropertyValue,
   StringPropertyValue,
 ]);
-const Equal = z
+const Equal: z.ZodType<Equal> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     value: PropertyValue,
   })
   .passthrough();
-const LateBoundEqual = z
+const LateBoundEqual: z.ZodType<LateBoundEqual> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const In = z
+const In: z.ZodType<In> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     values: z.array(PropertyValue),
   })
   .passthrough();
-const LateBoundIn = z
+const LateBoundIn: z.ZodType<LateBoundIn> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LessThan = z
+const LessThan: z.ZodType<LessThan> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     value: PropertyValue,
   })
   .passthrough();
-const LessThanOrEqual = z
+const LessThanOrEqual: z.ZodType<LessThanOrEqual> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     value: PropertyValue,
   })
   .passthrough();
-const GreaterThan = z
+const GreaterThan: z.ZodType<GreaterThan> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     value: PropertyValue,
   })
   .passthrough();
-const GreaterThanOrEqual = z
+const GreaterThanOrEqual: z.ZodType<GreaterThanOrEqual> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     value: PropertyValue,
   })
   .passthrough();
-const LateBoundLessThan = z
+const LateBoundLessThan: z.ZodType<LateBoundLessThan> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundLessThanOrEqual = z
+const LateBoundLessThanOrEqual: z.ZodType<LateBoundLessThanOrEqual> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundGreaterThan = z
+const LateBoundGreaterThan: z.ZodType<LateBoundGreaterThan> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundGreaterThanOrEqual = z
+const LateBoundGreaterThanOrEqual: z.ZodType<LateBoundGreaterThanOrEqual> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const Null = z
+const Null: z.ZodType<Null> = z
   .object({ "@type": z.string(), propertyId: z.string().regex(/\S/) })
   .passthrough();
-const StringContains = z
+const StringContains: z.ZodType<StringContains> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
@@ -936,7 +1386,7 @@ const StringContains = z
     caseInsensitive: z.boolean(),
   })
   .passthrough();
-const LateBoundStringContains = z
+const LateBoundStringContains: z.ZodType<LateBoundStringContains> = z
   .object({
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
@@ -975,8 +1425,10 @@ const Aggregation = z.enum([
   "percentile",
   "sum",
 ]);
-const AggregationOption = z.object({ decimalValue: z.number() }).passthrough();
-const AggregateProperty = z
+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(),
@@ -985,21 +1437,21 @@ const AggregateProperty = z
     aggregationOption: AggregationOption.nullish(),
   })
   .passthrough();
-const SourceProperty = z
+const SourceProperty: z.ZodType<SourceProperty> = z
   .object({
     targetPropertyId: z.string().nullable(),
     "@type": z.string(),
     propertyId: z.string().regex(/\S/),
   })
   .passthrough();
-const FormulaProperty = z
+const FormulaProperty: z.ZodType<FormulaProperty> = z
   .object({
     targetPropertyId: z.string().nullable(),
     "@type": z.string(),
     formula: z.string(),
   })
   .passthrough();
-const Property = z.discriminatedUnion("@type", [
+const Property: z.ZodType<Property> = z.discriminatedUnion("@type", [
   AggregateProperty,
   SourceProperty,
   FormulaProperty,
@@ -1012,7 +1464,7 @@ const CalendarInterval = z.enum([
   "hour",
   "minute",
 ]);
-const CalendarIntervalGrouping = z
+const CalendarIntervalGrouping: z.ZodType<CalendarIntervalGrouping> = z
   .object({
     propertyId: z.string().regex(/\S/),
     targetPropertyId: z.string().nullable(),
@@ -1027,7 +1479,7 @@ const DatePart = z.enum([
   "month-of-year",
   "hour-of-day",
 ]);
-const DatePartGrouping = z
+const DatePartGrouping: z.ZodType<DatePartGrouping> = z
   .object({
     propertyId: z.string().regex(/\S/),
     targetPropertyId: z.string().nullable(),
@@ -1036,7 +1488,7 @@ const DatePartGrouping = z
     targetTimezone: z.string().optional(),
   })
   .passthrough();
-const DecimalIntervalGrouping = z
+const DecimalIntervalGrouping: z.ZodType<DecimalIntervalGrouping> = z
   .object({
     propertyId: z.string().regex(/\S/),
     targetPropertyId: z.string().nullable(),
@@ -1044,7 +1496,7 @@ const DecimalIntervalGrouping = z
     interval: z.number().gt(0),
   })
   .passthrough();
-const IntegerIntervalGrouping = z
+const IntegerIntervalGrouping: z.ZodType<IntegerIntervalGrouping> = z
   .object({
     propertyId: z.string().regex(/\S/),
     targetPropertyId: z.string().nullable(),
@@ -1052,14 +1504,14 @@ const IntegerIntervalGrouping = z
     interval: z.number().int().gt(0),
   })
   .passthrough();
-const ValueGrouping = z
+const ValueGrouping: z.ZodType<ValueGrouping> = z
   .object({
     propertyId: z.string().regex(/\S/),
     targetPropertyId: z.string().nullable(),
     "@type": z.string(),
   })
   .passthrough();
-const Grouping = z.discriminatedUnion("@type", [
+const Grouping: z.ZodType<Grouping> = z.discriminatedUnion("@type", [
   CalendarIntervalGrouping,
   DatePartGrouping,
   DecimalIntervalGrouping,
@@ -1067,7 +1519,7 @@ const Grouping = z.discriminatedUnion("@type", [
   ValueGrouping,
 ]);
 const SortDirection = z.enum(["asc", "desc"]);
-const Sort = z
+const Sort: z.ZodType<Sort> = z
   .object({ sortDirection: SortDirection, propertyId: z.string().regex(/\S/) })
   .passthrough();
 const And1: z.ZodType<And1> = z.lazy(() =>
@@ -1083,74 +1535,74 @@ const Or1: z.ZodType<Or1> = z.lazy(() =>
 const Not1: z.ZodType<Not1> = z.lazy(() =>
   z.object({ "@type": z.string(), value: Having }).passthrough()
 );
-const Equal1 = z
+const Equal1: z.ZodType<Equal1> = z
   .object({ "@type": z.string(), property: Property, value: PropertyValue })
   .passthrough();
-const LateBoundEqual1 = z
+const LateBoundEqual1: z.ZodType<LateBoundEqual1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const In1 = z
+const In1: z.ZodType<In1> = z
   .object({
     "@type": z.string(),
     property: Property,
     values: z.array(PropertyValue),
   })
   .passthrough();
-const LateBoundIn1 = z
+const LateBoundIn1: z.ZodType<LateBoundIn1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LessThan1 = z
+const LessThan1: z.ZodType<LessThan1> = z
   .object({ "@type": z.string(), property: Property, value: PropertyValue })
   .passthrough();
-const LessThanOrEqual1 = z
+const LessThanOrEqual1: z.ZodType<LessThanOrEqual1> = z
   .object({ "@type": z.string(), property: Property, value: PropertyValue })
   .passthrough();
-const GreaterThan1 = z
+const GreaterThan1: z.ZodType<GreaterThan1> = z
   .object({ "@type": z.string(), property: Property, value: PropertyValue })
   .passthrough();
-const GreaterThanOrEqual1 = z
+const GreaterThanOrEqual1: z.ZodType<GreaterThanOrEqual1> = z
   .object({ "@type": z.string(), property: Property, value: PropertyValue })
   .passthrough();
-const LateBoundLessThan1 = z
+const LateBoundLessThan1: z.ZodType<LateBoundLessThan1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundLessThanOrEqual1 = z
+const LateBoundLessThanOrEqual1: z.ZodType<LateBoundLessThanOrEqual1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundGreaterThan1 = z
+const LateBoundGreaterThan1: z.ZodType<LateBoundGreaterThan1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const LateBoundGreaterThanOrEqual1 = z
+const LateBoundGreaterThanOrEqual1: z.ZodType<LateBoundGreaterThanOrEqual1> = z
   .object({
     "@type": z.string(),
     property: Property,
     valueVariableReference: z.string().regex(/\S/),
   })
   .passthrough();
-const Null1 = z
+const Null1: z.ZodType<Null1> = z
   .object({ "@type": z.string(), property: Property })
   .passthrough();
-const StringContains1 = z
+const StringContains1: z.ZodType<StringContains1> = z
   .object({
     "@type": z.string(),
     property: Property,
@@ -1158,7 +1610,7 @@ const StringContains1 = z
     caseInsensitive: z.boolean(),
   })
   .passthrough();
-const LateBoundStringContains1 = z
+const LateBoundStringContains1: z.ZodType<LateBoundStringContains1> = z
   .object({
     "@type": z.string(),
     property: Property,
@@ -1188,7 +1640,7 @@ const Having: z.ZodType<Having> = z.lazy(() =>
     LateBoundStringContains1,
   ])
 );
-const Computation = z
+const Computation: z.ZodType<Computation> = z
   .object({
     filter: Filter.nullable(),
     properties: z.array(Property),
@@ -1198,7 +1650,7 @@ const Computation = z
     includeRollup: z.boolean().optional(),
   })
   .passthrough();
-const QueryPreviewRequest = z
+const QueryPreviewRequest: z.ZodType<QueryPreviewRequest> = z
   .object({
     query: z.string().regex(/\S/),
     dataRequestParameters: DataRequestParameters,
@@ -1206,28 +1658,30 @@ const QueryPreviewRequest = z
     computation: Computation.nullable(),
   })
   .passthrough();
-const DataRecord = z
+const DataRecord: z.ZodType<DataRecord> = z
   .object({ propertyValues: z.record(z.array(PropertyValue)) })
   .passthrough();
-const DataPage = z.object({ dataRecords: z.array(DataRecord) }).passthrough();
-const DataSchema = z
+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
+const DataResponseMetadata: z.ZodType<DataResponseMetadata> = z
   .object({
     schema: DataSchema,
     totalResults: z.number().int().nullable(),
     renderedQuery: z.string().nullable(),
   })
   .passthrough();
-const CacheTelemetry = z
+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
+const RequestTelemetry: z.ZodType<RequestTelemetry> = z
   .object({
     requestTime: z.string().nullable(),
     queryTime: z.string().nullable(),
@@ -1235,14 +1689,14 @@ const RequestTelemetry = z
     cacheTelemetry: CacheTelemetry.nullish(),
   })
   .passthrough();
-const QueryExecutionResponse = z
+const QueryExecutionResponse: z.ZodType<QueryExecutionResponse> = z
   .object({
     data: DataPage,
     meta: DataResponseMetadata,
     requestTelemetry: RequestTelemetry.nullable(),
   })
   .passthrough();
-const QueryExecutionError = z
+const QueryExecutionError: z.ZodType<QueryExecutionError> = z
   .object({
     renderedQuery: z.string().nullable(),
     requestTelemetry: RequestTelemetry.nullable(),
@@ -1250,17 +1704,17 @@ const QueryExecutionError = z
     "@type": z.string(),
   })
   .passthrough();
-const TablePreviewRequest = z
+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
+const DateTimeFormat: z.ZodType<DateTimeFormat> = z
   .object({ pattern: z.string(), exportFormat: z.string().optional() })
   .passthrough();
-const DateTimeColumnFormat = z
+const DateTimeColumnFormat: z.ZodType<DateTimeColumnFormat> = z
   .object({
     "@type": z.string(),
     dateTimeFormatPattern: DateTimeFormat.nullish(),
@@ -1270,7 +1724,7 @@ const DateTimeColumnFormat = z
   })
   .passthrough();
 const UnitOfMeasurement = z.literal("CURRENCY");
-const DecimalColumnFormat = z
+const DecimalColumnFormat: z.ZodType<DecimalColumnFormat> = z
   .object({
     "@type": z.string(),
     decimalFormat: z.string().nullable(),
@@ -1280,36 +1734,36 @@ const DecimalColumnFormat = z
     multiplier: z.number().nullable(),
   })
   .passthrough();
-const DurationColumnFormat = z
+const DurationColumnFormat: z.ZodType<DurationColumnFormat> = z
   .object({ "@type": z.string(), durationPattern: z.string().nullable() })
   .passthrough();
-const ColumnFormat = z.discriminatedUnion("@type", [
+const ColumnFormat: z.ZodType<ColumnFormat> = z.discriminatedUnion("@type", [
   DateTimeColumnFormat,
   DecimalColumnFormat,
   DurationColumnFormat,
 ]);
-const ExportColumnOptions = z
+const ExportColumnOptions: z.ZodType<ExportColumnOptions> = z
   .object({
     targetPropertyId: z.string(),
     displayName: z.string().nullable(),
     columnFormat: ColumnFormat.nullable(),
   })
   .passthrough();
-const ExportTargetConfiguration = z
+const ExportTargetConfiguration: z.ZodType<ExportTargetConfiguration> = z
   .object({
     fileName: z.string().nullable(),
     exportFormat: ExportFormat,
     columnDisplayOptions: z.array(ExportColumnOptions),
   })
   .passthrough();
-const EmailConfiguration = z
+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
+const ViewExportRequest: z.ZodType<ViewExportRequest> = z
   .object({
     queryContext: z.object({}).partial().passthrough(),
     computation: Computation.nullable(),
@@ -1317,21 +1771,22 @@ const ViewExportRequest = z
     emailConfiguration: EmailConfiguration.nullable(),
   })
   .passthrough();
-const QueryExportEmailResponse = z
+const QueryExportEmailResponse: z.ZodType<QueryExportEmailResponse> = z
   .object({ "@type": z.string() })
   .passthrough();
-const QueryExportLinkResponse = z
+const QueryExportLinkResponse: z.ZodType<QueryExportLinkResponse> = z
   .object({ "@type": z.string(), url: z.string().regex(/\S/) })
   .passthrough();
-const QueryExportResponse = z.discriminatedUnion("@type", [
-  QueryExportEmailResponse,
-  QueryExportLinkResponse,
-]);
-const RequestExecutionParameters = z
+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
+const ViewRunRequest: z.ZodType<ViewRunRequest> = z
   .object({
     dataRequestParameters: DataRequestParameters,
     requestExecutionParameters: RequestExecutionParameters.nullable(),
@@ -1339,7 +1794,7 @@ const ViewRunRequest = z
     computation: Computation.nullable(),
   })
   .passthrough();
-const View = z
+const View: z.ZodType<View> = z
   .object({
     name: z.string().max(200).regex(/\S/),
     path: z.string().nullable(),
@@ -1368,11 +1823,13 @@ const View = z
       .nullish(),
   })
   .passthrough();
-const ViewResponse = z.object({ view: View }).passthrough();
-const ListViewsResponse = z
+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
+const TenantS3Configuration: z.ZodType<TenantS3Configuration> = z
   .object({
     prefix: z.string(),
     bucket: z.string(),
@@ -1380,13 +1837,13 @@ const TenantS3Configuration = z
     roleArn: z.string(),
   })
   .passthrough();
-const TenantRequest = z
+const TenantRequest: z.ZodType<TenantRequest> = z
   .object({
     configurationOverrides: z.record(z.string()).optional(),
     s3Configuration: TenantS3Configuration.nullable(),
   })
   .passthrough();
-const TenantKey = z
+const TenantKey: z.ZodType<TenantKey> = z
   .object({
     id: z
       .string()
@@ -1398,7 +1855,7 @@ const TenantKey = z
     value: z.string().nullable(),
   })
   .passthrough();
-const Tenant = z
+const Tenant: z.ZodType<Tenant> = z
   .object({
     id: z
       .string()
@@ -1411,8 +1868,10 @@ const Tenant = z
     s3Configuration: TenantS3Configuration.nullable(),
   })
   .passthrough();
-const TenantResponse = z.object({ tenant: Tenant }).passthrough();
-const VersionedViewRequest = z
+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}/
@@ -1422,9 +1881,70 @@ const VersionedViewRequest = z
     ).uuid(),
   })
   .passthrough();
-const ListVersionedViewsRequest = z
+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,
@@ -1586,9 +2106,19 @@ export const schemas = {
   TenantResponse,
   VersionedViewRequest,
   ListVersionedViewsRequest,
+  Commit,
+  CommitResponse,
+  QueryTimeoutError,
+  DataSourceError,
+  ListNamespacesResponse,
+  ListViewsRequest,
+  SearchBranchContentResponse,
+  TestConnectionResponse,
+  ViewRequest,
+  ViewResponse1,
 };
 
-const endpoints = makeApi([
+const Branch_ResourceEndpoints = makeApi([
   {
     method: "get",
     path: "/v1/branches",
@@ -1626,29 +2156,35 @@ const endpoints = makeApi([
     ],
   },
   {
-    method: "post",
-    path: "/v1/branches/:branchId/commits",
-    alias: "createCommit",
+    method: "get",
+    path: "/v1/branches/diff",
+    alias: "diffBranch",
     requestFormat: "json",
     parameters: [
       {
-        name: "body",
-        description: `Branch to create`,
-        type: "Body",
-        schema: CreateCommitRequest,
+        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: "branchId",
-        type: "Path",
+        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(),
+          .uuid()
+          .optional(),
       },
     ],
-    response: CreateCommitResponse,
+    response: DiffBranchResponse,
     errors: [
       {
         status: NaN,
@@ -1689,13 +2225,19 @@ const endpoints = makeApi([
     ],
   },
   {
-    method: "get",
-    path: "/v1/branches/:id/contents:path",
-    alias: "listBranchContent",
+    method: "post",
+    path: "/v1/branches/:targetBranchId/merge",
+    alias: "mergeBranch",
     requestFormat: "json",
     parameters: [
       {
-        name: "id",
+        name: "body",
+        description: `Options for merge`,
+        type: "Body",
+        schema: MergeBranchRequest,
+      },
+      {
+        name: "targetBranchId",
         type: "Path",
         schema: z
           .string()
@@ -1705,25 +2247,12 @@ const endpoints = makeApi([
           .uuid(),
       },
       {
-        name: "path",
-        type: "Path",
-        schema: z
-          .string()
-          .regex(/(\/.+)?/)
-          .default("/"),
-      },
-      {
-        name: "page",
-        type: "Query",
-        schema: z.number().int().optional().default(0),
-      },
-      {
-        name: "perPage",
+        name: "isForce",
         type: "Query",
-        schema: z.number().int().optional().default(50),
+        schema: z.boolean(),
       },
     ],
-    response: ListBranchContentResponse,
+    response: BranchResponse,
     errors: [
       {
         status: NaN,
@@ -1732,20 +2261,25 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Branch_ResourceApi = new Zodios(Branch_ResourceEndpoints);
+
+const Commit_ResourceEndpoints = makeApi([
   {
     method: "post",
-    path: "/v1/branches/:targetBranchId/merge",
-    alias: "mergeBranch",
+    path: "/v1/branches/:branchId/commits",
+    alias: "createCommit",
     requestFormat: "json",
     parameters: [
       {
         name: "body",
-        description: `Options for merge`,
+        description: `Branch to create`,
         type: "Body",
-        schema: MergeBranchRequest,
+        schema: CreateCommitRequest,
       },
       {
-        name: "targetBranchId",
+        name: "branchId",
         type: "Path",
         schema: z
           .string()
@@ -1754,13 +2288,8 @@ const endpoints = makeApi([
           )
           .uuid(),
       },
-      {
-        name: "isForce",
-        type: "Query",
-        schema: z.boolean(),
-      },
     ],
-    response: BranchResponse,
+    response: CreateCommitResponse,
     errors: [
       {
         status: NaN,
@@ -1769,36 +2298,47 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Commit_ResourceApi = new Zodios(Commit_ResourceEndpoints);
+
+const Branch_Content_ResourceEndpoints = makeApi([
   {
     method: "get",
-    path: "/v1/branches/diff",
-    alias: "diffBranch",
+    path: "/v1/branches/:id/contents:path",
+    alias: "listBranchContent",
     requestFormat: "json",
     parameters: [
       {
-        name: "from",
-        type: "Query",
+        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()
-          .optional(),
+          .uuid(),
       },
       {
-        name: "to",
-        type: "Query",
+        name: "path",
+        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()
-          .optional(),
+          .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: DiffBranchResponse,
+    response: ListBranchContentResponse,
     errors: [
       {
         status: NaN,
@@ -1807,6 +2347,13 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Branch_Content_ResourceApi = new Zodios(
+  Branch_Content_ResourceEndpoints
+);
+
+const Test_Connection_ResourceEndpoints = makeApi([
   {
     method: "post",
     path: "/v1/data-sources/retest-connection/:id",
@@ -1865,6 +2412,13 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Test_Connection_ResourceApi = new Zodios(
+  Test_Connection_ResourceEndpoints
+);
+
+const Health_ResourceEndpoints = makeApi([
   {
     method: "get",
     path: "/v1/health",
@@ -1901,6 +2455,11 @@ const endpoints = makeApi([
     ],
     response: z.object({}).partial().passthrough(),
   },
+]);
+
+export const Health_ResourceApi = new Zodios(Health_ResourceEndpoints);
+
+const Namespace_ResourceEndpoints = makeApi([
   {
     method: "post",
     path: "/v1/namespaces",
@@ -1923,6 +2482,34 @@ const endpoints = makeApi([
       },
     ],
   },
+  {
+    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",
@@ -1998,7 +2585,194 @@ const endpoints = makeApi([
     requestFormat: "json",
     parameters: [
       {
-        name: "id",
+        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()
@@ -2008,7 +2782,7 @@ const endpoints = makeApi([
           .uuid(),
       },
     ],
-    response: z.object({}).partial().passthrough(),
+    response: ListViewsResponse,
     errors: [
       {
         status: NaN,
@@ -2019,15 +2793,19 @@ const endpoints = makeApi([
   },
   {
     method: "post",
-    path: "/v1/namespaces/:namespaceId/data-sources",
-    alias: "createDataSource",
+    path: "/v1/namespaces/:namespaceId/data-sources/:id/views/sync",
+    alias: "syncTables",
     requestFormat: "json",
     parameters: [
       {
-        name: "body",
-        description: `Data Source object to create`,
-        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",
@@ -2040,7 +2818,7 @@ const endpoints = makeApi([
           .uuid(),
       },
     ],
-    response: DataSourceResponse,
+    response: ListViewsResponse,
     errors: [
       {
         status: NaN,
@@ -2049,6 +2827,13 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Data_Source_ResourceApi = new Zodios(
+  Data_Source_ResourceEndpoints
+);
+
+const Query_ResourceEndpoints = makeApi([
   {
     method: "post",
     path: "/v1/namespaces/:namespaceId/data-sources/:dataSourceId/preview",
@@ -2371,192 +3156,11 @@ const endpoints = makeApi([
       },
     ],
   },
-  {
-    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 Query_ResourceApi = new Zodios(Query_ResourceEndpoints);
+
+const View_ResourceEndpoints = makeApi([
   {
     method: "get",
     path: "/v1/namespaces/:namespaceId/views/:id",
@@ -2639,34 +3243,11 @@ const endpoints = makeApi([
       },
     ],
   },
-  {
-    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,
-      },
-    ],
-  },
+]);
+
+export const View_ResourceApi = new Zodios(View_ResourceEndpoints);
+
+const Tenant_ResourceEndpoints = makeApi([
   {
     method: "post",
     path: "/v1/tenants",
@@ -2773,6 +3354,11 @@ const endpoints = makeApi([
       },
     ],
   },
+]);
+
+export const Tenant_ResourceApi = new Zodios(Tenant_ResourceEndpoints);
+
+const List_Views_ResourceEndpoints = makeApi([
   {
     method: "post",
     path: "/v1/views/batch-get",
@@ -2797,7 +3383,7 @@ const endpoints = makeApi([
   },
 ]);
 
-export const api = new Zodios(endpoints);
+export const List_Views_ResourceApi = new Zodios(List_Views_ResourceEndpoints);
 
 export function createApiClient(baseUrl: string, options?: ZodiosOptions) {
   return new Zodios(baseUrl, endpoints, options);