@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

package/src/common/schema/sets.test.ts.bak

@@ -0,0 +1,108 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  UniqueStringSetPayloadSchema,
+  UniqueStringPayloadSchema,
+} from './sets.js';
+
+describe('Common Schema - Sets', () => {
+  describe('UniqueStringSetPayloadSchema', () => {
+    test('should accept Set of strings', () => {
+      const stringSet = new Set(['a', 'b', 'c']);
+      const result = UniqueStringSetPayloadSchema(stringSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should accept array of strings and convert to Set', () => {
+      const stringArray = ['x', 'y', 'z'];
+      const result = UniqueStringSetPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['x', 'y', 'z']);
+    });
+
+    test('should handle duplicate strings in array', () => {
+      const stringArray = ['a', 'b', 'a', 'c', 'b'];
+      const result = UniqueStringSetPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect(Array.from(result as Set<string>).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should accept empty array', () => {
+      const result = UniqueStringSetPayloadSchema([]);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect((result as Set<string>).size).toBe(0);
+    });
+
+    test('should accept empty Set', () => {
+      const emptySet = new Set<string>();
+      const result = UniqueStringSetPayloadSchema(emptySet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBeInstanceOf(Set);
+      expect((result as Set<string>).size).toBe(0);
+    });
+
+    test('should reject non-string array elements', () => {
+      const result = UniqueStringSetPayloadSchema(['a', 123, 'b']);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-array, non-Set values', () => {
+      expect(UniqueStringSetPayloadSchema('string')).toBeInstanceOf(
+        type.errors
+      );
+      expect(UniqueStringSetPayloadSchema(123)).toBeInstanceOf(type.errors);
+      expect(UniqueStringSetPayloadSchema({})).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UniqueStringPayloadSchema', () => {
+    test('should convert Set to array', () => {
+      const stringSet = new Set(['x', 'y', 'z']);
+      const result = UniqueStringPayloadSchema(stringSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(Array.isArray(result)).toBe(true);
+      expect((result as string[]).sort()).toEqual(['x', 'y', 'z']);
+    });
+
+    test('should convert array to unique array', () => {
+      const stringArray = ['a', 'b', 'a', 'c', 'b'];
+      const result = UniqueStringPayloadSchema(stringArray);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(Array.isArray(result)).toBe(true);
+      expect((result as string[]).sort()).toEqual(['a', 'b', 'c']);
+    });
+
+    test('should handle empty inputs', () => {
+      const emptySet = new Set<string>();
+      const emptyArray: string[] = [];
+
+      const setResult = UniqueStringPayloadSchema(emptySet);
+      const arrayResult = UniqueStringPayloadSchema(emptyArray);
+
+      expect(setResult).not.toBeInstanceOf(type.errors);
+      expect(arrayResult).not.toBeInstanceOf(type.errors);
+      expect((setResult as string[]).length).toBe(0);
+      expect((arrayResult as string[]).length).toBe(0);
+    });
+
+    test('should maintain order from original Set', () => {
+      const orderedSet = new Set(['first', 'second', 'third']);
+      const result = UniqueStringPayloadSchema(orderedSet);
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(['first', 'second', 'third']);
+    });
+  });
+});

package/src/customer/users/schema.test.ts.bak

@@ -0,0 +1,138 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../schema.js';
+import {
+  InsertUserPayloadSchema,
+  UserPayloadSchema,
+  UserStatus,
+} from './schema.js';
+
+describe('Customer - User', () => {
+  describe('User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        status: UserStatus.ACTIVE,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      const result = UserPayloadSchema(
+        item
+      ) as typeof UserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+    });
+  });
+
+  describe('Insert User Payload', () => {
+    test('should parse attributes successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        familyName: 'Foo',
+        phoneNumber: '123',
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.undefined;
+      expect(result?.familyName).to.equal(item.familyName);
+    });
+
+    test('should serialize successfully', async () => {
+      const item = {
+        foo: 'bar',
+        id: generateUserId(),
+        phoneNumber: '123',
+        metadata: new Map(),
+        // status: UserStatus.ACTIVE,
+        // createdAt: new Date(),
+        // updatedAt: new Date(),
+      };
+
+      const result = InsertUserPayloadSchema(
+        item
+      ) as typeof InsertUserPayloadSchema.inferOut;
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result?.metadata).to.null;
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should serialize nulls successfully', async () => {
+      const payload = {
+        id: generateUserId(),
+        status: 'unverified',
+        givenName: null,
+        middleName: null,
+        familyName: null,
+        honorificPrefix: null,
+        honorificSuffix: null,
+        email: null,
+        verifiedEmail: null,
+        phoneNumber: null,
+        verifiedPhoneNumber: null,
+        createdAt: '2025-04-02T03:50:40.812Z',
+        updatedAt: '2025-04-02T03:50:40.812Z',
+      };
+
+      const test = type({
+        foo: 'string.numeric.parse',
+        bar: 'number',
+        baz: 'string.date.iso.parse',
+      });
+
+      const result = UserPayloadSchema(payload);
+
+      if (result instanceof type.errors) {
+        console.log(result.summary);
+      }
+
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/identity/schema.test.ts.bak

@@ -0,0 +1,48 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { IdentityIdentifier, IdentityIdentifierSchema } from './schema.js';
+
+describe('Identity - Schema', () => {
+  describe('IdentityIdentifier constants', () => {
+    test('should have correct identifier values', () => {
+      expect(IdentityIdentifier.EMAIL).toBe('email');
+      expect(IdentityIdentifier.PHONE_NUMBER).toBe('phoneNumber');
+    });
+  });
+
+  describe('IdentityIdentifierSchema', () => {
+    test('should accept valid email identifier', () => {
+      const result = IdentityIdentifierSchema('email');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('email');
+    });
+
+    test('should accept valid phone number identifier', () => {
+      const result = IdentityIdentifierSchema('phoneNumber');
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toBe('phoneNumber');
+    });
+
+    test('should reject invalid identifiers', () => {
+      expect(IdentityIdentifierSchema('username')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('invalid')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('')).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject non-string values', () => {
+      expect(IdentityIdentifierSchema(123)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(null)).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema(undefined)).toBeInstanceOf(type.errors);
+    });
+
+    test('should be case sensitive', () => {
+      expect(IdentityIdentifierSchema('Email')).toBeInstanceOf(type.errors);
+      expect(IdentityIdentifierSchema('PHONE_NUMBER')).toBeInstanceOf(
+        type.errors
+      );
+      expect(IdentityIdentifierSchema('phonenumber')).toBeInstanceOf(
+        type.errors
+      );
+    });
+  });
+});

package/src/oauth/token/schema/schema.test.ts.bak

@@ -0,0 +1,142 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../../../app/utils.js';
+import { Schema } from './schema.js';
+
+describe('OAuth Token - Schema', () => {
+  describe('Schema union', () => {
+    test('should accept authorization code grant', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with PKCE', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+        code_verifier: 'pkce_verifier_123',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept authorization code with client secret', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept client credentials grant', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read write',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept refresh token grant', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        refresh_token: 'refresh_token_123',
+        client_id: generateAppId(),
+        client_secret: 'secret_123',
+        scope: 'read',
+      };
+
+      const result = Schema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should reject invalid grant type', () => {
+      const payload = {
+        grant_type: 'invalid_grant',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'https://example.com/callback',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject authorization code without required fields', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        client_id: generateAppId(),
+        // missing code and redirect_uri
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid redirect URI', () => {
+      const payload = {
+        grant_type: 'authorization_code',
+        code: 'auth_code_123',
+        client_id: generateAppId(),
+        redirect_uri: 'not-a-valid-url',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject client credentials without required fields', () => {
+      const payload = {
+        grant_type: 'client_credentials',
+        client_id: generateAppId(),
+        // missing client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject refresh token without required fields', () => {
+      const payload = {
+        grant_type: 'refresh_token',
+        client_id: 'app_123',
+        // missing refresh_token and client_secret
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+
+    test('should reject completely invalid payload', () => {
+      const payload = {
+        invalid: 'data',
+      };
+
+      const result = Schema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+});

package/src/workspace/settings/schema.test.ts.bak

@@ -0,0 +1,88 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import {
+  SettingsPayloadSchema,
+  UpsertSettingsPayloadSchema,
+} from './schema.js';
+
+describe('Workspace Settings - Schema', () => {
+  describe('SettingsPayloadSchema', () => {
+    test('should accept complete settings payload', () => {
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        deletedAt: new Date().toISOString(),
+        deactivatedAt: new Date().toISOString(),
+        metadata: { version: '1.0', theme: 'dark' },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept minimal settings payload', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept payload with some optional dates', () => {
+      const payload = {
+        updatedAt: new Date().toISOString(),
+        metadata: { lastModified: 'now' },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should accept payload with only metadata', () => {
+      const payload = {
+        metadata: {
+          preferences: 'yes',
+        },
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+    });
+
+    test('should reject invalid date format', () => {
+      const payload = {
+        updatedAt: 'invalid-date',
+        metadata: {},
+      };
+
+      const result = SettingsPayloadSchema(payload);
+      expect(result).toBeInstanceOf(type.errors);
+    });
+  });
+
+  describe('UpsertSettingsPayloadSchema', () => {
+    test('should accept metadata for upsert', () => {
+      const payload = {
+        metadata: {
+          settings: 'light',
+        },
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+
+    test('should accept empty metadata', () => {
+      const payload = {
+        metadata: {},
+      };
+
+      const result = UpsertSettingsPayloadSchema(payload);
+      expect(result).not.toBeInstanceOf(type.errors);
+      expect(result).toEqual(payload);
+    });
+  });
+});

package/dist/cjs/app/schema/app.d.ts

@@ -1,58 +0,0 @@
-export declare const AppStatus: {
-    readonly ENABLED: "enabled";
-    readonly DISABLED: "disabled";
-};
-export type AnyAppStatus = (typeof AppStatus)[keyof typeof AppStatus];
-export declare const AppIdSchema: import("arktype/out/methods/string.js").StringType<string, {}>;
-export type AppId = typeof AppIdSchema.inferOut;
-export declare const AppIdPropertySchema: import("arktype/out/methods/object.js").ObjectType<{
-    id: string;
-}, {}>;
-export type AppIdProperty = typeof AppIdPropertySchema.inferOut;
-export declare const AppPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
-    status: "enabled" | "disabled";
-    label: string;
-    createdAt: (In: string | Date) => import("arktype/out/attributes.js").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype/out/attributes.js").Out<string>;
-    description?: string | undefined;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes.js").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes.js").Out<string | undefined>) | undefined;
-    id: string;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes.js").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type AppPayload = typeof AppPayloadSchema.inferOut;
-export declare const InsertAppPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
-    id: import("arktype/out/attributes.js").Default<string, string>;
-    status: import("arktype/out/attributes.js").Default<"enabled" | "disabled", "enabled">;
-    label: string;
-    description?: string | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes.js").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type InsertAppPayload = typeof InsertAppPayloadSchema.inferOut;
-export declare const UpdateAppPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
-    status?: "enabled" | "disabled" | undefined;
-    label?: string | null | undefined;
-    description?: string | null | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes.js").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type UpdateAppPayload = typeof UpdateAppPayloadSchema.inferOut;
-export declare const AppAssociationReferenceSchema: import("arktype/out/methods/object.js").ObjectType<{
-    id: string;
-    status: "enabled" | "disabled";
-    label: string;
-    model: "App";
-}, {}>;
-export type AppAssociationReference = typeof AppAssociationReferenceSchema.inferOut;
-//# sourceMappingURL=app.d.ts.map

package/dist/cjs/app/schema/app.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../../src/app/schema/app.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,WAAW,gEAAc,CAAC;AACvC,MAAM,MAAM,KAAK,GAAG,OAAO,WAAW,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mBAAmB;;MAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAIhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAUQ,CAAC;AACtC,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;MAKE,CAAC;AACtC,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,sBAAsB;;;;;;;;;MAIE,CAAC;AACtC,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;MAMzC,CAAC;AACF,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC"}

package/dist/cjs/app/schema/app.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppAssociationReferenceSchema = exports.UpdateAppPayloadSchema = exports.InsertAppPayloadSchema = exports.AppPayloadSchema = exports.AppIdPropertySchema = exports.AppIdSchema = exports.AppStatus = void 0;
-const arktype_1 = require("arktype");
-const index_js_1 = require("../../common/index.js");
-const metadata_js_1 = require("../../common/schema/metadata.js");
-const utils_js_1 = require("./utils.js");
-exports.AppStatus = {
-    ENABLED: 'enabled',
-    DISABLED: 'disabled',
-};
-exports.AppIdSchema = arktype_1.type.string;
-exports.AppIdPropertySchema = (0, arktype_1.type)({
-    id: exports.AppIdSchema,
-});
-const StatusSchema = arktype_1.type.enumerated(exports.AppStatus.ENABLED, exports.AppStatus.DISABLED);
-exports.AppPayloadSchema = (0, arktype_1.type)({
-    status: StatusSchema,
-    label: (0, arktype_1.type)('string'),
-    description: (0, arktype_1.type)('string | undefined').optional(),
-    createdAt: index_js_1.RequiredDatePayloadSchema,
-    updatedAt: index_js_1.RequiredDatePayloadSchema,
-    'deletedAt?': index_js_1.OptionalDatePayloadSchema,
-    'deactivatedAt?': index_js_1.OptionalDatePayloadSchema,
-})
-    .and(exports.AppIdPropertySchema)
-    .and(metadata_js_1.MetadataPayloadPropertySchema);
-exports.InsertAppPayloadSchema = (0, arktype_1.type)({
-    id: exports.AppIdSchema.default(() => (0, utils_js_1.generateAppId)()),
-    status: StatusSchema.default(exports.AppStatus.ENABLED),
-    label: (0, arktype_1.type)('string'),
-    description: (0, arktype_1.type)('string').optional(),
-}).and(metadata_js_1.MetadataPayloadPropertySchema);
-exports.UpdateAppPayloadSchema = (0, arktype_1.type)({
-    status: StatusSchema.optional(),
-    label: (0, arktype_1.type)('string').or(arktype_1.type.null).optional(),
-    description: (0, arktype_1.type)('string').or(arktype_1.type.null).optional(),
-}).and(metadata_js_1.MetadataPayloadPropertySchema);
-exports.AppAssociationReferenceSchema = exports.AppIdPropertySchema.and((0, arktype_1.type)({
-    status: StatusSchema,
-    label: (0, arktype_1.type)('string'),
-    model: "'App'",
-}));

package/dist/cjs/app/schema/authorization.d.ts

@@ -1,37 +0,0 @@
-import { type AnyGrantType } from '../../oauth/common/schema.js';
-export declare const AuthorizationPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
-    refreshTokenDuration: import("arktype/out/attributes.js").Default<number, number>;
-    accessTokenDuration: import("arktype/out/attributes.js").Default<number, number>;
-    accessTokenSignatureAlgorithm: import("arktype/out/attributes.js").Default<string, string>;
-    loginUri?: string | undefined;
-    callbackUrls?: ((In: Set<string> | string[] | undefined) => import("arktype/out/attributes.js").Out<string[] | undefined>) | undefined;
-    availableGrants?: ((In: Set<AnyGrantType> | ("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined) => import("arktype/out/attributes.js").Out<("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined>) | undefined;
-    availableAudiences?: ((In: Set<string> | string[] | undefined) => import("arktype/out/attributes.js").Out<string[] | undefined>) | undefined;
-    defaultAudience?: string | undefined;
-    updatedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes.js").Out<string | undefined>) | undefined;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes.js").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/out/attributes.js").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes.js").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type AuthorizationPayload = typeof AuthorizationPayloadSchema.inferOut;
-export declare const UpsertAuthorizationPayloadSchema: import("arktype/out/methods/object.js").ObjectType<{
-    refreshTokenDuration: import("arktype/out/attributes.js").Default<number, number>;
-    accessTokenDuration: import("arktype/out/attributes.js").Default<number, number>;
-    accessTokenSignatureAlgorithm: import("arktype/out/attributes.js").Default<string, string>;
-    loginUri?: string | undefined;
-    callbackUrls?: ((In: Set<string> | string[] | undefined) => import("arktype/out/attributes.js").Out<string[] | undefined>) | undefined;
-    availableGrants?: ("client_credentials" | "authorization_code" | "implicit" | "refresh_token")[] | undefined;
-    availableAudiences?: string[] | undefined;
-    defaultAudience?: string | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/out/attributes.js").Out<{
-        [x: string]: string | number | boolean;
-    } | null>) | undefined;
-}, {}>;
-export type UpsertAuthorizationPayload = typeof UpsertAuthorizationPayloadSchema.inferOut;
-//# sourceMappingURL=authorization.d.ts.map

package/dist/cjs/app/schema/authorization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../src/app/schema/authorization.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,8BAA8B,CAAC;AAiC5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;MASF,CAAC;AACtC,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;MAcF,CAAC;AAC5C,MAAM,MAAM,0BAA0B,GACpC,OAAO,gCAAgC,CAAC,QAAQ,CAAC"}