@objectstack/spec 0.2.0 → 0.3.1

package/dist/system/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * System Protocol Exports
+ *
+ * Runtime Configuration & Security
+ * - Manifest (Config), Datasource
+ * - Role (Hierarchy), Identity (Auth)
+ * - Webhook (Integration), Policy (Compliance)
+ * - Plugin Architecture
+ */
+export * from './manifest.zod';
+export * from './datasource.zod';
+export * from './api.zod';
+export * from './identity.zod';
+export * from './auth.zod';
+export * from './auth-protocol';
+export * from './organization.zod';
+export * from './policy.zod';
+export * from './role.zod';
+export * from './territory.zod';
+export * from './tenant.zod';
+export * from './audit.zod';
+export * from './license.zod';
+export * from './webhook.zod';
+export * from './translation.zod';
+export * from './driver.zod';
+export * from './discovery.zod';
+export * from './plugin.zod';
+export * from './realtime.zod';
+export * from './events.zod';
+export * from './job.zod';
+export * from './constants';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/dist/system/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * System Protocol Exports
+ *
+ * Runtime Configuration & Security
+ * - Manifest (Config), Datasource
+ * - Role (Hierarchy), Identity (Auth)
+ * - Webhook (Integration), Policy (Compliance)
+ * - Plugin Architecture
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./manifest.zod"), exports);
+__exportStar(require("./datasource.zod"), exports);
+__exportStar(require("./api.zod"), exports);
+__exportStar(require("./identity.zod"), exports);
+__exportStar(require("./auth.zod"), exports);
+__exportStar(require("./auth-protocol"), exports);
+__exportStar(require("./organization.zod"), exports);
+__exportStar(require("./policy.zod"), exports);
+__exportStar(require("./role.zod"), exports);
+__exportStar(require("./territory.zod"), exports);
+__exportStar(require("./tenant.zod"), exports);
+__exportStar(require("./audit.zod"), exports);
+__exportStar(require("./license.zod"), exports);
+__exportStar(require("./webhook.zod"), exports);
+__exportStar(require("./translation.zod"), exports);
+__exportStar(require("./driver.zod"), exports);
+__exportStar(require("./discovery.zod"), exports);
+__exportStar(require("./plugin.zod"), exports);
+__exportStar(require("./realtime.zod"), exports);
+__exportStar(require("./events.zod"), exports);
+__exportStar(require("./job.zod"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+/**
+ * Cron Schedule Schema
+ * Schedule jobs using cron expressions
+ */
+export declare const CronScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "cron";
+    expression: string;
+    timezone: string;
+}, {
+    type: "cron";
+    expression: string;
+    timezone?: string | undefined;
+}>;
+/**
+ * Interval Schedule Schema
+ * Schedule jobs at fixed intervals
+ */
+export declare const IntervalScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    intervalMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "interval";
+    intervalMs: number;
+}, {
+    type: "interval";
+    intervalMs: number;
+}>;
+/**
+ * Once Schedule Schema
+ * Schedule a job to run once at a specific time
+ */
+export declare const OnceScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"once">;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "once";
+}, {
+    at: string;
+    type: "once";
+}>;
+/**
+ * Schedule Schema
+ * Discriminated union of all schedule types
+ */
+export declare const ScheduleSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "cron";
+    expression: string;
+    timezone: string;
+}, {
+    type: "cron";
+    expression: string;
+    timezone?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    intervalMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "interval";
+    intervalMs: number;
+}, {
+    type: "interval";
+    intervalMs: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"once">;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "once";
+}, {
+    at: string;
+    type: "once";
+}>]>;
+export type Schedule = z.infer<typeof ScheduleSchema>;
+export type CronSchedule = z.infer<typeof CronScheduleSchema>;
+export type IntervalSchedule = z.infer<typeof IntervalScheduleSchema>;
+export type OnceSchedule = z.infer<typeof OnceScheduleSchema>;
+/**
+ * Retry Policy Schema
+ * Configuration for job retry behavior with exponential backoff
+ */
+export declare const RetryPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    backoffMs: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+}, {
+    maxRetries?: number | undefined;
+    backoffMs?: number | undefined;
+    backoffMultiplier?: number | undefined;
+}>;
+export type RetryPolicy = z.infer<typeof RetryPolicySchema>;
+/**
+ * Job Schema
+ * Defines a scheduled job
+ */
+export declare const JobSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    schedule: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        intervalMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        intervalMs: number;
+    }, {
+        type: "interval";
+        intervalMs: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        type: "once";
+    }, {
+        at: string;
+        type: "once";
+    }>]>;
+    handler: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMs: number;
+        backoffMultiplier: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMs?: number | undefined;
+        backoffMultiplier?: number | undefined;
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    schedule: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        intervalMs: number;
+    } | {
+        at: string;
+        type: "once";
+    };
+    id: string;
+    enabled: boolean;
+    handler: (...args: unknown[]) => Promise<void>;
+    timeout?: number | undefined;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMs: number;
+        backoffMultiplier: number;
+    } | undefined;
+}, {
+    name: string;
+    schedule: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        intervalMs: number;
+    } | {
+        at: string;
+        type: "once";
+    };
+    id: string;
+    handler: (...args: unknown[]) => Promise<void>;
+    timeout?: number | undefined;
+    enabled?: boolean | undefined;
+    retryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMs?: number | undefined;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+}>;
+export type Job = z.infer<typeof JobSchema>;
+/**
+ * Job Execution Status Enum
+ * Status of job execution
+ */
+export declare const JobExecutionStatus: z.ZodEnum<["running", "success", "failed", "timeout"]>;
+export type JobExecutionStatus = z.infer<typeof JobExecutionStatus>;
+/**
+ * Job Execution Schema
+ * Logs for job execution
+ */
+export declare const JobExecutionSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["running", "success", "failed", "timeout"]>;
+    error: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "success" | "running" | "failed";
+    jobId: string;
+    startedAt: string;
+    error?: string | undefined;
+    duration?: number | undefined;
+    completedAt?: string | undefined;
+}, {
+    status: "timeout" | "success" | "running" | "failed";
+    jobId: string;
+    startedAt: string;
+    error?: string | undefined;
+    duration?: number | undefined;
+    completedAt?: string | undefined;
+}>;
+export type JobExecution = z.infer<typeof JobExecutionSchema>;
+//# sourceMappingURL=job.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"job.zod.d.ts","sourceRoot":"","sources":["../../src/system/job.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpB,CAAC;AAEH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,kBAAkB,wDAK7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/system/job.zod.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobExecutionSchema = exports.JobExecutionStatus = exports.JobSchema = exports.RetryPolicySchema = exports.ScheduleSchema = exports.OnceScheduleSchema = exports.IntervalScheduleSchema = exports.CronScheduleSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Cron Schedule Schema
+ * Schedule jobs using cron expressions
+ */
+exports.CronScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('cron'),
+    expression: zod_1.z.string().describe('Cron expression (e.g., "0 0 * * *" for daily at midnight)'),
+    timezone: zod_1.z.string().optional().default('UTC').describe('Timezone for cron execution (e.g., "America/New_York")'),
+});
+/**
+ * Interval Schedule Schema
+ * Schedule jobs at fixed intervals
+ */
+exports.IntervalScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('interval'),
+    intervalMs: zod_1.z.number().int().positive().describe('Interval in milliseconds'),
+});
+/**
+ * Once Schedule Schema
+ * Schedule a job to run once at a specific time
+ */
+exports.OnceScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('once'),
+    at: zod_1.z.string().datetime().describe('ISO 8601 datetime when to execute'),
+});
+/**
+ * Schedule Schema
+ * Discriminated union of all schedule types
+ */
+exports.ScheduleSchema = zod_1.z.discriminatedUnion('type', [
+    exports.CronScheduleSchema,
+    exports.IntervalScheduleSchema,
+    exports.OnceScheduleSchema,
+]);
+/**
+ * Retry Policy Schema
+ * Configuration for job retry behavior with exponential backoff
+ */
+exports.RetryPolicySchema = zod_1.z.object({
+    maxRetries: zod_1.z.number().int().min(0).default(3).describe('Maximum number of retry attempts'),
+    backoffMs: zod_1.z.number().int().positive().default(1000).describe('Initial backoff delay in milliseconds'),
+    backoffMultiplier: zod_1.z.number().positive().default(2).describe('Multiplier for exponential backoff'),
+});
+/**
+ * Job Schema
+ * Defines a scheduled job
+ */
+exports.JobSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('Unique job identifier'),
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Job name (snake_case)'),
+    schedule: exports.ScheduleSchema.describe('Job schedule configuration'),
+    handler: zod_1.z.function().returns(zod_1.z.promise(zod_1.z.void())).describe('Job handler function'),
+    retryPolicy: exports.RetryPolicySchema.optional().describe('Retry policy configuration'),
+    timeout: zod_1.z.number().int().positive().optional().describe('Timeout in milliseconds'),
+    enabled: zod_1.z.boolean().default(true).describe('Whether the job is enabled'),
+});
+/**
+ * Job Execution Status Enum
+ * Status of job execution
+ */
+exports.JobExecutionStatus = zod_1.z.enum([
+    'running',
+    'success',
+    'failed',
+    'timeout',
+]);
+/**
+ * Job Execution Schema
+ * Logs for job execution
+ */
+exports.JobExecutionSchema = zod_1.z.object({
+    jobId: zod_1.z.string().describe('Job identifier'),
+    startedAt: zod_1.z.string().datetime().describe('ISO 8601 datetime when execution started'),
+    completedAt: zod_1.z.string().datetime().optional().describe('ISO 8601 datetime when execution completed'),
+    status: exports.JobExecutionStatus.describe('Execution status'),
+    error: zod_1.z.string().optional().describe('Error message if failed'),
+    duration: zod_1.z.number().int().optional().describe('Execution duration in milliseconds'),
+});

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

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+/**
+ * Organization Schema (Multi-Tenant Architecture)
+ *
+ * Defines the standard organization/workspace model for ObjectStack.
+ * Supports B2B SaaS scenarios where users belong to multiple teams/workspaces.
+ *
+ * This aligns with better-auth's organization plugin capabilities.
+ */
+/**
+ * Organization Schema
+ * Represents a team, workspace, or tenant in a multi-tenant application
+ */
+export declare const OrganizationSchema: z.ZodObject<{
+    /**
+     * Unique organization identifier
+     */
+    id: z.ZodString;
+    /**
+     * Organization name (display name)
+     */
+    name: z.ZodString;
+    /**
+     * Organization slug (URL-friendly identifier)
+     * Must be unique across all organizations
+     */
+    slug: z.ZodString;
+    /**
+     * Organization logo URL
+     */
+    logo: z.ZodOptional<z.ZodString>;
+    /**
+     * Custom metadata for the organization
+     * Can store additional configuration, settings, or custom fields
+     */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Organization creation timestamp
+     */
+    createdAt: z.ZodDate;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    slug: string;
+    logo?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    slug: string;
+    logo?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export type Organization = z.infer<typeof OrganizationSchema>;
+/**
+ * Organization Member Schema
+ * Links users to organizations with specific roles
+ */
+export declare const MemberSchema: z.ZodObject<{
+    /**
+     * Unique member identifier
+     */
+    id: z.ZodString;
+    /**
+     * Organization ID this membership belongs to
+     */
+    organizationId: z.ZodString;
+    /**
+     * User ID of the member
+     */
+    userId: z.ZodString;
+    /**
+     * Member's role within the organization
+     * Common roles: 'owner', 'admin', 'member', 'guest'
+     * Can be customized per application
+     */
+    role: z.ZodString;
+    /**
+     * Member creation timestamp
+     */
+    createdAt: z.ZodDate;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    organizationId: string;
+    role: string;
+}, {
+    id: string;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    organizationId: string;
+    role: string;
+}>;
+export type Member = z.infer<typeof MemberSchema>;
+/**
+ * Invitation Status Enum
+ */
+export declare const InvitationStatus: z.ZodEnum<["pending", "accepted", "rejected", "expired"]>;
+export type InvitationStatus = z.infer<typeof InvitationStatus>;
+/**
+ * Organization Invitation Schema
+ * Represents an invitation to join an organization
+ */
+export declare const InvitationSchema: z.ZodObject<{
+    /**
+     * Unique invitation identifier
+     */
+    id: z.ZodString;
+    /**
+     * Organization ID the invitation is for
+     */
+    organizationId: z.ZodString;
+    /**
+     * Email address of the invitee
+     */
+    email: z.ZodString;
+    /**
+     * Role the invitee will receive upon accepting
+     * Common roles: 'admin', 'member', 'guest'
+     */
+    role: z.ZodString;
+    /**
+     * Invitation status
+     */
+    status: z.ZodDefault<z.ZodEnum<["pending", "accepted", "rejected", "expired"]>>;
+    /**
+     * Invitation expiration timestamp
+     */
+    expiresAt: z.ZodDate;
+    /**
+     * User ID of the person who sent the invitation
+     */
+    inviterId: z.ZodString;
+    /**
+     * Invitation creation timestamp
+     */
+    createdAt: z.ZodDate;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    status: "pending" | "accepted" | "rejected" | "expired";
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date;
+    organizationId: string;
+    role: string;
+    inviterId: string;
+}, {
+    email: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date;
+    organizationId: string;
+    role: string;
+    inviterId: string;
+    status?: "pending" | "accepted" | "rejected" | "expired" | undefined;
+}>;
+export type Invitation = z.infer<typeof InvitationSchema>;
+//# sourceMappingURL=organization.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"organization.zod.d.ts","sourceRoot":"","sources":["../../src/system/organization.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;OAEG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAKH;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;;OAIG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,gBAAgB,2DAAyD,CAAC;AAEvF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}