@objectstack/spec 0.1.0 → 0.1.2

package/dist/system/datasource.zod.d.ts

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+/**
+ * Driver Type Enum (Built-in)
+ * Standard drivers supported by the core platform.
+ * Plugins can register additional drivers using different identifiers.
+ */
+export declare const BuiltInDrivers: readonly ["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"];
+/**
+ * Driver Identifier
+ * Can be a built-in driver or a plugin-contributed driver (e.g., "com.vendor.snowflake").
+ */
+export declare const DriverType: z.ZodString;
+/**
+ * Driver Definition Schema
+ * Metadata describing a Database Driver.
+ * Plugins use this to register new connectivity options.
+ */
+export declare const DriverDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    /**
+     * Configuration Schema (JSON Schema)
+     * Describes the structure of the `config` object needed for this driver.
+     * Used by the UI to generate the connection form.
+     */
+    configSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * Default Capabilities
+     * What this driver supports out-of-the-box.
+     */
+    capabilities: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        /** Can execute SQL-like joins natively? */
+        joins: z.ZodDefault<z.ZodBoolean>;
+        /** Can handle ACID transactions? */
+        transactions: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform full-text search? */
+        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform aggregation (group by, sum, avg)? */
+        aggregation: z.ZodDefault<z.ZodBoolean>;
+        /** Is scheme-less (needs schema inference)? */
+        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+        /** Is read-only? */
+        readOnly: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    }, {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    id: string;
+    configSchema: Record<string, any>;
+    description?: string | undefined;
+    icon?: string | undefined;
+    capabilities?: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    } | undefined;
+}, {
+    label: string;
+    id: string;
+    configSchema: Record<string, any>;
+    description?: string | undefined;
+    icon?: string | undefined;
+    capabilities?: {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * Datasource Capabilities Schema
+ * Declares what this datasource naturally supports.
+ * The ObjectQL engine uses this to determine what logic to push down
+ * and what to compute in memory.
+ */
+export declare const DatasourceCapabilities: z.ZodObject<{
+    /** Can execute SQL-like joins natively? */
+    joins: z.ZodDefault<z.ZodBoolean>;
+    /** Can handle ACID transactions? */
+    transactions: z.ZodDefault<z.ZodBoolean>;
+    /** Can perform full-text search? */
+    fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+    /** Can perform aggregation (group by, sum, avg)? */
+    aggregation: z.ZodDefault<z.ZodBoolean>;
+    /** Is scheme-less (needs schema inference)? */
+    dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+    /** Is read-only? */
+    readOnly: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    joins: boolean;
+    transactions: boolean;
+    fullTextSearch: boolean;
+    aggregation: boolean;
+    dynamicSchema: boolean;
+    readOnly: boolean;
+}, {
+    joins?: boolean | undefined;
+    transactions?: boolean | undefined;
+    fullTextSearch?: boolean | undefined;
+    aggregation?: boolean | undefined;
+    dynamicSchema?: boolean | undefined;
+    readOnly?: boolean | undefined;
+}>;
+/**
+ * Datasource Schema
+ * Represents a connection to an external data store.
+ */
+export declare const DatasourceSchema: z.ZodObject<{
+    /** Machine Name */
+    name: z.ZodString;
+    /** Human Label */
+    label: z.ZodOptional<z.ZodString>;
+    /** Driver */
+    driver: z.ZodString;
+    /**
+     * Connection Configuration
+     * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
+     * Stored securely (passwords usually interpolated from ENV).
+     */
+    config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * Capability Overrides
+     * Manually override what the driver claims to support.
+     */
+    capabilities: z.ZodOptional<z.ZodObject<{
+        /** Can execute SQL-like joins natively? */
+        joins: z.ZodDefault<z.ZodBoolean>;
+        /** Can handle ACID transactions? */
+        transactions: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform full-text search? */
+        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform aggregation (group by, sum, avg)? */
+        aggregation: z.ZodDefault<z.ZodBoolean>;
+        /** Is scheme-less (needs schema inference)? */
+        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+        /** Is read-only? */
+        readOnly: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    }, {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    }>>;
+    /** Description */
+    description: z.ZodOptional<z.ZodString>;
+    /** Is enabled? */
+    active: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    active: boolean;
+    config: Record<string, any>;
+    driver: string;
+    label?: string | undefined;
+    description?: string | undefined;
+    capabilities?: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    } | undefined;
+}, {
+    name: string;
+    config: Record<string, any>;
+    driver: string;
+    label?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    capabilities?: {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    } | undefined;
+}>;
+export type Datasource = z.infer<typeof DatasourceSchema>;
+export type DatasourceConfig = z.infer<typeof DatasourceCapabilities>;
+//# sourceMappingURL=datasource.zod.d.ts.map

package/dist/system/datasource.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.zod.d.ts","sourceRoot":"","sources":["../../src/system/datasource.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,cAAc,+KAMjB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,UAAU,aAAsD,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;IAMjC;;;;OAIG;;IAGH;;;OAGG;;QAWH,2CAA2C;;QAE3C,oCAAoC;;QAEpC,oCAAoC;;QAEpC,oDAAoD;;QAEpD,+CAA+C;;QAE/C,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAnBpB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;IACjC,2CAA2C;;IAE3C,oCAAoC;;IAEpC,oCAAoC;;IAEpC,oDAAoD;;IAEpD,+CAA+C;;IAE/C,oBAAoB;;;;;;;;;;;;;;;;EAEpB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,mBAAmB;;IAGnB,kBAAkB;;IAGlB,aAAa;;IAGb;;;;OAIG;;IAGH;;;OAGG;;QAtCH,2CAA2C;;QAE3C,oCAAoC;;QAEpC,oCAAoC;;QAEpC,oDAAoD;;QAEpD,+CAA+C;;QAE/C,oBAAoB;;;;;;;;;;;;;;;;;IA+BpB,kBAAkB;;IAGlB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/system/datasource.zod.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasourceSchema = exports.DatasourceCapabilities = exports.DriverDefinitionSchema = exports.DriverType = exports.BuiltInDrivers = void 0;
+const zod_1 = require("zod");
+/**
+ * Driver Type Enum (Built-in)
+ * Standard drivers supported by the core platform.
+ * Plugins can register additional drivers using different identifiers.
+ */
+exports.BuiltInDrivers = [
+    'postgres', 'mysql', 'sqlserver', 'oracle', 'sqlite', // SQL
+    'mongo', 'redis', // NoSQL
+    'excel', 'csv', 'airtable', // Spreadsheet / Low-code
+    'rest_api', 'graphql', 'odata', // Web Services
+    'salesforce', 'sap', 'workday' // Enterprise SaaS
+];
+/**
+ * Driver Identifier
+ * Can be a built-in driver or a plugin-contributed driver (e.g., "com.vendor.snowflake").
+ */
+exports.DriverType = zod_1.z.string().describe('Underlying driver identifier');
+/**
+ * Driver Definition Schema
+ * Metadata describing a Database Driver.
+ * Plugins use this to register new connectivity options.
+ */
+exports.DriverDefinitionSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('Unique driver identifier (e.g. "postgres")'),
+    label: zod_1.z.string().describe('Display label (e.g. "PostgreSQL")'),
+    description: zod_1.z.string().optional(),
+    icon: zod_1.z.string().optional(),
+    /**
+     * Configuration Schema (JSON Schema)
+     * Describes the structure of the `config` object needed for this driver.
+     * Used by the UI to generate the connection form.
+     */
+    configSchema: zod_1.z.record(zod_1.z.any()).describe('JSON Schema for connection configuration'),
+    /**
+     * Default Capabilities
+     * What this driver supports out-of-the-box.
+     */
+    capabilities: zod_1.z.lazy(() => exports.DatasourceCapabilities).optional(),
+});
+/**
+ * Datasource Capabilities Schema
+ * Declares what this datasource naturally supports.
+ * The ObjectQL engine uses this to determine what logic to push down
+ * and what to compute in memory.
+ */
+exports.DatasourceCapabilities = zod_1.z.object({
+    /** Can execute SQL-like joins natively? */
+    joins: zod_1.z.boolean().default(false),
+    /** Can handle ACID transactions? */
+    transactions: zod_1.z.boolean().default(false),
+    /** Can perform full-text search? */
+    fullTextSearch: zod_1.z.boolean().default(false),
+    /** Can perform aggregation (group by, sum, avg)? */
+    aggregation: zod_1.z.boolean().default(false),
+    /** Is scheme-less (needs schema inference)? */
+    dynamicSchema: zod_1.z.boolean().default(false),
+    /** Is read-only? */
+    readOnly: zod_1.z.boolean().default(false),
+});
+/**
+ * Datasource Schema
+ * Represents a connection to an external data store.
+ */
+exports.DatasourceSchema = zod_1.z.object({
+    /** Machine Name */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique datasource identifier'),
+    /** Human Label */
+    label: zod_1.z.string().optional().describe('Display label'),
+    /** Driver */
+    driver: exports.DriverType.describe('Underlying driver type'),
+    /**
+     * Connection Configuration
+     * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
+     * Stored securely (passwords usually interpolated from ENV).
+     */
+    config: zod_1.z.record(zod_1.z.any()).describe('Driver specific configuration'),
+    /**
+     * Capability Overrides
+     * Manually override what the driver claims to support.
+     */
+    capabilities: exports.DatasourceCapabilities.optional().describe('Capability overrides'),
+    /** Description */
+    description: zod_1.z.string().optional().describe('Internal description'),
+    /** Is enabled? */
+    active: zod_1.z.boolean().default(true).describe('Is datasource enabled'),
+});

package/dist/system/discovery.zod.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+/**
+ * API Capabilities Schema
+ * Defines what features are enabled on this ObjectOS instance.
+ */
+export declare const ApiCapabilitiesSchema: z.ZodObject<{
+    graphql: z.ZodDefault<z.ZodBoolean>;
+    search: z.ZodDefault<z.ZodBoolean>;
+    websockets: z.ZodDefault<z.ZodBoolean>;
+    files: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    search: boolean;
+    files: boolean;
+    graphql: boolean;
+    websockets: boolean;
+}, {
+    search?: boolean | undefined;
+    files?: boolean | undefined;
+    graphql?: boolean | undefined;
+    websockets?: boolean | undefined;
+}>;
+/**
+ * API Routes Schema
+ * The "Map" for the frontend to know where to send requests.
+ * This decouples the frontend from hardcoded URL paths.
+ */
+export declare const ApiRoutesSchema: z.ZodObject<{
+    /** Base URL for Object CRUD (Standard Data API) */
+    data: z.ZodString;
+    /** Base URL for Schema Definitions (Metadata API) */
+    metadata: z.ZodString;
+    /** Base URL for Authentication */
+    auth: z.ZodString;
+    /** Base URL for Server Actions/Flows */
+    actions: z.ZodOptional<z.ZodString>;
+    /** Base URL for File/Storage operations */
+    storage: z.ZodOptional<z.ZodString>;
+    /** GraphQL Endpoint (if enabled) */
+    graphql: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    metadata: string;
+    auth: string;
+    actions?: string | undefined;
+    graphql?: string | undefined;
+    storage?: string | undefined;
+}, {
+    data: string;
+    metadata: string;
+    auth: string;
+    actions?: string | undefined;
+    graphql?: string | undefined;
+    storage?: string | undefined;
+}>;
+/**
+ * Discovery Response Schema
+ * The root object returned by the Metadata Discovery Endpoint.
+ */
+export declare const DiscoverySchema: z.ZodObject<{
+    /** System Identity */
+    name: z.ZodString;
+    version: z.ZodString;
+    environment: z.ZodEnum<["production", "sandbox", "development"]>;
+    /** Dynamic Routing */
+    routes: z.ZodObject<{
+        /** Base URL for Object CRUD (Standard Data API) */
+        data: z.ZodString;
+        /** Base URL for Schema Definitions (Metadata API) */
+        metadata: z.ZodString;
+        /** Base URL for Authentication */
+        auth: z.ZodString;
+        /** Base URL for Server Actions/Flows */
+        actions: z.ZodOptional<z.ZodString>;
+        /** Base URL for File/Storage operations */
+        storage: z.ZodOptional<z.ZodString>;
+        /** GraphQL Endpoint (if enabled) */
+        graphql: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        metadata: string;
+        auth: string;
+        actions?: string | undefined;
+        graphql?: string | undefined;
+        storage?: string | undefined;
+    }, {
+        data: string;
+        metadata: string;
+        auth: string;
+        actions?: string | undefined;
+        graphql?: string | undefined;
+        storage?: string | undefined;
+    }>;
+    /** Feature Flags */
+    features: z.ZodObject<{
+        graphql: z.ZodDefault<z.ZodBoolean>;
+        search: z.ZodDefault<z.ZodBoolean>;
+        websockets: z.ZodDefault<z.ZodBoolean>;
+        files: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        search: boolean;
+        files: boolean;
+        graphql: boolean;
+        websockets: boolean;
+    }, {
+        search?: boolean | undefined;
+        files?: boolean | undefined;
+        graphql?: boolean | undefined;
+        websockets?: boolean | undefined;
+    }>;
+    /** Localization Info (helping frontend init i18n) */
+    locale: z.ZodObject<{
+        default: z.ZodString;
+        supported: z.ZodArray<z.ZodString, "many">;
+        timezone: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        default: string;
+        supported: string[];
+        timezone: string;
+    }, {
+        default: string;
+        supported: string[];
+        timezone: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    locale: {
+        default: string;
+        supported: string[];
+        timezone: string;
+    };
+    features: {
+        search: boolean;
+        files: boolean;
+        graphql: boolean;
+        websockets: boolean;
+    };
+    environment: "production" | "sandbox" | "development";
+    routes: {
+        data: string;
+        metadata: string;
+        auth: string;
+        actions?: string | undefined;
+        graphql?: string | undefined;
+        storage?: string | undefined;
+    };
+}, {
+    name: string;
+    version: string;
+    locale: {
+        default: string;
+        supported: string[];
+        timezone: string;
+    };
+    features: {
+        search?: boolean | undefined;
+        files?: boolean | undefined;
+        graphql?: boolean | undefined;
+        websockets?: boolean | undefined;
+    };
+    environment: "production" | "sandbox" | "development";
+    routes: {
+        data: string;
+        metadata: string;
+        auth: string;
+        actions?: string | undefined;
+        graphql?: string | undefined;
+        storage?: string | undefined;
+    };
+}>;
+export type DiscoveryResponse = z.infer<typeof DiscoverySchema>;
+export type ApiRoutes = z.infer<typeof ApiRoutesSchema>;
+export type ApiCapabilities = z.infer<typeof ApiCapabilitiesSchema>;
+//# sourceMappingURL=discovery.zod.d.ts.map

package/dist/system/discovery.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.zod.d.ts","sourceRoot":"","sources":["../../src/system/discovery.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;IAC1B,mDAAmD;;IAGnD,qDAAqD;;IAGrD,kCAAkC;;IAGlC,wCAAwC;;IAGxC,2CAA2C;;IAG3C,oCAAoC;;;;;;;;;;;;;;;;EAEpC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B,sBAAsB;;;;IAKtB,sBAAsB;;QA7BtB,mDAAmD;;QAGnD,qDAAqD;;QAGrD,kCAAkC;;QAGlC,wCAAwC;;QAGxC,2CAA2C;;QAG3C,oCAAoC;;;;;;;;;;;;;;;;;IAiBpC,oBAAoB;;;;;;;;;;;;;;;;;IAGpB,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrD,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAChE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/system/discovery.zod.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverySchema = exports.ApiRoutesSchema = exports.ApiCapabilitiesSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * API Capabilities Schema
+ * Defines what features are enabled on this ObjectOS instance.
+ */
+exports.ApiCapabilitiesSchema = zod_1.z.object({
+    graphql: zod_1.z.boolean().default(false),
+    search: zod_1.z.boolean().default(false),
+    websockets: zod_1.z.boolean().default(false),
+    files: zod_1.z.boolean().default(true),
+});
+/**
+ * API Routes Schema
+ * The "Map" for the frontend to know where to send requests.
+ * This decouples the frontend from hardcoded URL paths.
+ */
+exports.ApiRoutesSchema = zod_1.z.object({
+    /** Base URL for Object CRUD (Standard Data API) */
+    data: zod_1.z.string().describe('e.g. /api/v1/data'),
+    /** Base URL for Schema Definitions (Metadata API) */
+    metadata: zod_1.z.string().describe('e.g. /api/v1/meta'),
+    /** Base URL for Authentication */
+    auth: zod_1.z.string().describe('e.g. /api/v1/auth'),
+    /** Base URL for Server Actions/Flows */
+    actions: zod_1.z.string().optional().describe('e.g. /api/v1/p'),
+    /** Base URL for File/Storage operations */
+    storage: zod_1.z.string().optional().describe('e.g. /api/v1/storage'),
+    /** GraphQL Endpoint (if enabled) */
+    graphql: zod_1.z.string().optional().describe('e.g. /api/v1/graphql'),
+});
+/**
+ * Discovery Response Schema
+ * The root object returned by the Metadata Discovery Endpoint.
+ */
+exports.DiscoverySchema = zod_1.z.object({
+    /** System Identity */
+    name: zod_1.z.string(),
+    version: zod_1.z.string(),
+    environment: zod_1.z.enum(['production', 'sandbox', 'development']),
+    /** Dynamic Routing */
+    routes: exports.ApiRoutesSchema,
+    /** Feature Flags */
+    features: exports.ApiCapabilitiesSchema,
+    /** Localization Info (helping frontend init i18n) */
+    locale: zod_1.z.object({
+        default: zod_1.z.string(),
+        supported: zod_1.z.array(zod_1.z.string()),
+        timezone: zod_1.z.string(),
+    }),
+});