@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.3

package/dist/esm/common/schema/collection.d.ts

@@ -0,0 +1,18 @@
+import { type Pagination } from './pagination.js';
+export declare const CollectionSchema: import("arktype").Generic<[["t", unknown]], {
+    readonly items: "t[]";
+}, {}, {}>;
+export type Collection<I> = {
+    items: I[];
+};
+export declare const PaginationCollectionSchema: import("arktype").Generic<[["t", unknown]], {
+    readonly items: "t[]";
+    readonly pagination: [import("arktype/internal/methods/object.ts").ObjectType<{
+        pageSize?: string | number | undefined;
+        nextToken?: string | undefined;
+    }, {}>, "?"];
+}, {}, {}>;
+export type PaginationCollection<I> = Collection<I> & {
+    pagination?: Pagination;
+};
+//# sourceMappingURL=collection.d.ts.map

package/dist/esm/common/schema/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;UAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;UAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACpD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC"}

package/dist/esm/common/schema/collection.js

@@ -0,0 +1,7 @@
+import { type } from 'arktype';
+import { PaginationSchema } from './pagination.js';
+export const CollectionSchema = type('<t>', { items: 't[]' });
+export const PaginationCollectionSchema = type('<t>', {
+    items: 't[]',
+    pagination: PaginationSchema.optional(),
+});

package/dist/esm/common/schema/dates.d.ts

@@ -0,0 +1,39 @@
+export declare const RequiredDateSchema: import("arktype/internal/methods/object.ts").ObjectType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>), {}>;
+export declare const OptionalDateSchema: import("arktype/internal/methods/base.ts").BaseType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined, {}>;
+export type AnyRequiredDateType = typeof RequiredDateSchema.inferIn;
+export type RequiredDate = typeof RequiredDateSchema.inferOut;
+export type AnyOptionalDate = typeof OptionalDateSchema.inferIn;
+export type OptionalDate = typeof OptionalDateSchema.inferOut;
+export declare const RequiredDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date) => import("arktype/internal/attributes.ts").Out<string>, {}>;
+export declare const OptionalDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>, {}>;
+export type RequiredDatePayload = typeof RequiredDatePayloadSchema.inferOut;
+export type OptionalDatePayload = typeof OptionalDatePayloadSchema.inferOut;
+/**
+ * Created At
+ */
+export declare const CreatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+}, {}>;
+export type CreatedAtPropertyPayload = typeof CreatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Updated At
+ */
+export declare const UpdatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+}, {}>;
+export type UpdatedAtPropertyPayload = typeof UpdatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deleted At
+ */
+export declare const DeletedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeletedAtPropertyPayload = typeof DeletedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deactivated At
+ */
+export declare const DeactivatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeactivatedAtPropertyPayload = typeof DeactivatedAtPropertyPayloadSchema.inferOut;
+//# sourceMappingURL=dates.d.ts.map

package/dist/esm/common/schema/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,yIAA2C,CAAC;AAC3E,eAAO,MAAM,kBAAkB,iJAAqC,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAG9D,eAAO,MAAM,yBAAyB,0IAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,kKAErC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,kCAAkC;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC"}

package/dist/esm/common/schema/dates.js

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+// Normalizing to a Date object
+export const RequiredDateSchema = type('Date').or('string.date.iso.parse');
+export const OptionalDateSchema = RequiredDateSchema.or('undefined');
+// What the class property is serialized to
+export const RequiredDatePayloadSchema = RequiredDateSchema.pipe.try((d) => d.toISOString());
+export const OptionalDatePayloadSchema = OptionalDateSchema.pipe.try((d) => d?.toISOString());
+/**
+ * Created At
+ */
+export const CreatedAtPropertyPayloadSchema = type({
+    createdAt: RequiredDatePayloadSchema,
+});
+/**
+ * Updated At
+ */
+export const UpdatedAtPropertyPayloadSchema = type({
+    updatedAt: RequiredDatePayloadSchema,
+});
+/**
+ * Deleted At
+ */
+export const DeletedAtPropertyPayloadSchema = type({
+    'deletedAt?': OptionalDatePayloadSchema,
+});
+/**
+ * Deactivated At
+ */
+export const DeactivatedAtPropertyPayloadSchema = type({
+    'deactivatedAt?': OptionalDatePayloadSchema,
+});

package/dist/esm/common/schema/dates.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dates.test.d.ts.map

package/dist/esm/common/schema/dates.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.test.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.test.ts"],"names":[],"mappings":""}

package/dist/esm/common/schema/dates.test.js

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
+describe('Common - Dates', () => {
+    describe('Date Schema', () => {
+        test('should accept an iso string', async () => {
+            const result = RequiredDateSchema(new Date().toISOString());
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Date);
+        });
+        test('should accept a Date object', async () => {
+            const result = RequiredDateSchema(new Date());
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Date);
+        });
+    });
+    describe('Payload Schema', () => {
+        test('should parse a Date to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = RequiredDatePayloadSchema(new Date(iso));
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).to.equal(iso);
+        });
+        test('should parse an ISO to an ISO string', async () => {
+            const iso = new Date().toISOString();
+            const result = RequiredDatePayloadSchema(iso);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).to.equal(iso);
+        });
+    });
+});

package/dist/esm/common/schema/jwt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+export declare const Algorithm: {
+    DEFAULT: string;
+    HS256: string;
+    HS384: string;
+    HS512: string;
+    RS256: string;
+    RS384: string;
+    RS512: string;
+    ES256: string;
+    ES384: string;
+    ES512: string;
+    PS256: string;
+    PS384: string;
+    PS512: string;
+};
+export type AnyAlgorithm = (typeof Algorithm)[keyof typeof Algorithm];
+export declare const AlgorithmSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+//# sourceMappingURL=jwt.d.ts.map

package/dist/esm/common/schema/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe,qEAY3B,CAAC"}

package/dist/esm/common/schema/jwt.js

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+export const Algorithm = {
+    // DEFAULT: 'ES256',
+    DEFAULT: 'RS256',
+    HS256: 'HS256',
+    HS384: 'HS384',
+    HS512: 'HS512',
+    RS256: 'RS256',
+    RS384: 'RS384',
+    RS512: 'RS512',
+    ES256: 'ES256',
+    ES384: 'ES384',
+    ES512: 'ES512',
+    PS256: 'PS256',
+    PS384: 'PS384',
+    PS512: 'PS512',
+};
+export const AlgorithmSchema = type.enumerated(Algorithm.HS256, Algorithm.HS384, Algorithm.HS512, Algorithm.RS256, Algorithm.RS384, Algorithm.RS512, Algorithm.ES256, Algorithm.ES384, Algorithm.PS256, Algorithm.PS384, Algorithm.PS512);

package/dist/esm/common/schema/metadata.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Record
+ */
+declare const MetadataRecordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    [x: string]: string | number | boolean;
+}, {}>;
+type MetadataRecord = typeof MetadataRecordSchema.inferOut;
+/**
+ * Map
+ */
+declare const MetadataMapSchema: import("arktype/internal/methods/object.ts").ObjectType<Map<string, string | number | boolean>, {}>;
+export type MetadataMap = typeof MetadataMapSchema.inferOut;
+export declare const MetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+    [x: string]: string | number | boolean;
+} | undefined>, {}>;
+export type MetadataPayload = typeof MetadataPayloadSchema.inferOut;
+export declare const MetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type MetadataPayloadProperty = typeof MetadataPayloadPropertySchema.inferOut;
+export declare const UpsertMetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+    [x: string]: string | number | boolean;
+} | null>, {}>;
+export declare const UpsertMetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export type UpsertMetadataPayloadProperty = typeof UpsertMetadataPayloadPropertySchema.inferOut;
+export declare function buildMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | undefined;
+export declare function buildUpsertMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | null;
+export declare const MetadataMapPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype/internal/attributes.ts").Out<Map<string, string | number | boolean> | Map<string, any>>;
+}, {}>;
+export type MetadataMapProperty = typeof MetadataMapPropertySchema.inferOut;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/esm/common/schema/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,QAAA,MAAM,oBAAoB;;MAA4C,CAAC;AACvE,KAAK,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAE3D;;GAEG;AACH,QAAA,MAAM,iBAAiB,qGAEtB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB;;;;mBAG6B,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;MAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;cAGgC,CAAC;AAEzE,eAAO,MAAM,mCAAmC;;;;;;MAE9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,SAAS,CAgB5B;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,IAAI,CAgBvB;AAQD,eAAO,MAAM,yBAAyB;;MAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}

package/dist/esm/common/schema/metadata.js

@@ -0,0 +1,83 @@
+import { match, type } from 'arktype';
+/**
+ * Value
+ */
+const MetadataValueSchema = type('string | number | boolean');
+/**
+ * Record
+ */
+const MetadataRecordSchema = type({ '[string]': MetadataValueSchema });
+/**
+ * Map
+ */
+const MetadataMapSchema = type.instanceOf((Map));
+/**
+ * Record To Map
+ */
+const MetadataMapMatch = match({
+    undefined: () => new Map(),
+})
+    .case(MetadataMapSchema, (s) => new Map(s))
+    .case(MetadataMapSchema, (s) => new Map(Object.entries(s || {}).map(([key, value]) => [key, value])))
+    .default(() => new Map());
+export const MetadataPayloadSchema = type('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildMetadataPayload(map) : undefined));
+export const MetadataPayloadPropertySchema = type({
+    'metadata?': MetadataPayloadSchema,
+});
+export const UpsertMetadataPayloadSchema = type('undefined | null')
+    .or(MetadataMapSchema)
+    .or(MetadataRecordSchema)
+    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null));
+export const UpsertMetadataPayloadPropertySchema = type({
+    'metadata?': UpsertMetadataPayloadSchema,
+});
+export function buildMetadataPayload(map) {
+    if (!(map instanceof Map)) {
+        return map;
+    }
+    const result = Array.from(map.entries()).reduce((result, [key, value]) => {
+        if (value == null || value === '') {
+            return result;
+        }
+        Object.assign(result, { [key]: value });
+        return result;
+    }, {});
+    return Object.keys(result).length ? result : undefined;
+}
+export function buildUpsertMetadataPayload(map) {
+    if (!(map instanceof Map)) {
+        return map;
+    }
+    const result = Array.from(map.entries()).reduce((result, [key, value]) => {
+        if (value == null || value === '') {
+            return result;
+        }
+        Object.assign(result, { [key]: value });
+        return result;
+    }, {});
+    return Object.keys(result).length ? result : null;
+}
+/**
+ * Map
+ */
+const ToMetadataMapSchema = MetadataMapMatch.default(() => new Map());
+export const MetadataMapPropertySchema = type({
+    metadata: ToMetadataMapSchema,
+});
+// export const metadataAttributeScope = scope({
+//   metadata: MetadataAttributeMatch.default(
+//     () => new Map<string, typeof MetadataAttributeValueSchema.inferOut>(),
+//   ),
+// });
+// export const metadataPropertyScope = scope({
+//   'metadata?': MetadataPropertyItemSchema,
+// });
+// export const serializedMetadataScope = scope({
+//   metadata: SerializedMetadataSchema,
+// });
+// export const storageMetadataScope = scope({
+//   metadata: StorageMetadataSchema,
+// });

package/dist/esm/common/schema/metadata.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metadata.test.d.ts.map

package/dist/esm/common/schema/metadata.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.test.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.test.ts"],"names":[],"mappings":""}

package/dist/esm/common/schema/metadata.test.js

@@ -0,0 +1,60 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from './metadata.js';
+describe('Common - Metadata', () => {
+    describe('Map Property Schema', () => {
+        test('should parse a record to a map', async () => {
+            const result = MetadataMapPropertySchema({
+                metadata: { foo: 'bar' },
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).toBeInstanceOf(Map);
+        });
+        test('should parse undefined property to a map', async () => {
+            const result = MetadataMapPropertySchema({
+                metadata: undefined,
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).toBeInstanceOf(Map);
+        });
+        test('should parse undefined to a map', async () => {
+            const result = MetadataMapPropertySchema({});
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).toBeInstanceOf(Map);
+        });
+        test('should parse map to a map', async () => {
+            const result = MetadataMapPropertySchema({
+                metadata: new Map([['foo', 'bar']]),
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).toBeInstanceOf(Map);
+        });
+        test('should parse null to a map', async () => {
+            const result = MetadataMapPropertySchema({
+                metadata: null,
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).toBeInstanceOf(Map);
+        });
+    });
+    describe('Payload', () => {
+        test('should parse map to record', async () => {
+            const result = MetadataPayloadPropertySchema({
+                metadata: new Map([
+                    ['foo', 'bar'],
+                    ['baz', 0],
+                ]),
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata?.foo).to.equal('bar');
+            expect(result?.metadata?.baz).to.equal(0);
+        });
+        test('should return undefined if map is empty', async () => {
+            const result = MetadataPayloadPropertySchema({
+                metadata: new Map(),
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata).is.undefined;
+        });
+    });
+});

package/dist/esm/common/schema/pagination.d.ts

@@ -0,0 +1,6 @@
+export declare const PaginationSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    pageSize?: string | number | undefined;
+    nextToken?: string | undefined;
+}, {}>;
+export type Pagination = typeof PaginationSchema.inferOut;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/esm/common/schema/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/pagination.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;MAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC"}

package/dist/esm/common/schema/pagination.js

@@ -0,0 +1,5 @@
+import { type } from 'arktype';
+export const PaginationSchema = type({
+    pageSize: type('string | number').optional(),
+    nextToken: type('string').optional(),
+});

package/dist/esm/common/schema/schema.d.ts

@@ -0,0 +1,8 @@
+export * from './aggregate.js';
+export * from './collection.js';
+export * from './dates.js';
+export * from './jwt.js';
+export * from './metadata.js';
+export * from './pagination.js';
+export * from './sets.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/common/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/schema.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/dist/esm/common/schema/schema.js

@@ -0,0 +1,7 @@
+export * from './aggregate.js';
+export * from './collection.js';
+export * from './dates.js';
+export * from './jwt.js';
+export * from './metadata.js';
+export * from './pagination.js';
+export * from './sets.js';

package/dist/esm/common/schema/sets.d.ts

@@ -0,0 +1,3 @@
+export declare const UniqueStringSetPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<Set<string> | ((In: string[]) => import("arktype/internal/attributes.ts").Out<Set<string>>), {}>;
+export declare const UniqueStringSetPayload: import("arktype/internal/methods/object.ts").ObjectType<(In: Set<string> | string[]) => import("arktype/internal/attributes.ts").Out<string[]>, {}>;
+//# sourceMappingURL=sets.d.ts.map

package/dist/esm/common/schema/sets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/sets.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,4BAA4B,0JAAiC,CAAC;AAC3E,eAAO,MAAM,sBAAsB,qJAElC,CAAC"}

package/dist/esm/common/schema/sets.js

@@ -0,0 +1,6 @@
+import { type } from 'arktype';
+const StringArraySchema = type('string[]');
+const StringArrayToSet = StringArraySchema.pipe((s) => new Set(s));
+const StringSet = type.instanceOf((Set));
+export const UniqueStringSetPayloadSchema = StringSet.or(StringArrayToSet);
+export const UniqueStringSetPayload = UniqueStringSetPayloadSchema.pipe((s) => Array.from(s.values()));

package/dist/esm/customer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schema/schema.js';
+export * from './users/resources.js';
+export * from './users/schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/customer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AAEnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC"}

package/dist/esm/customer/index.js

@@ -0,0 +1,3 @@
+export * from './schema/schema.js';
+export * from './users/resources.js';
+export * from './users/schema.js';

package/dist/esm/customer/schema/organization.d.ts

@@ -0,0 +1,54 @@
+export declare const OrganizationStatus: {
+    readonly ACTIVE: "active";
+    readonly SUSPENDED: "suspended";
+};
+export type AnyOrganizationStatus = (typeof OrganizationStatus)[keyof typeof OrganizationStatus];
+export declare const OrganizationIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type OrganizationId = typeof OrganizationIdSchema.inferOut;
+export declare const OrganizationIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type OrganizationIdProperty = typeof OrganizationIdPropertySchema.inferOut;
+export declare const OrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status: import("arktype/internal/attributes.ts").Default<"active" | "suspended", "active">;
+    name: string;
+    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
+    id: string;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type OrganizationPayload = typeof OrganizationPayloadSchema.inferOut;
+export declare const InsertOrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+    name: string;
+    status?: "active" | "suspended" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export type InsertOrganizationPayload = typeof InsertOrganizationPayloadSchema.inferOut;
+export declare const UpdateOrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status?: "active" | "suspended" | null | undefined;
+    name?: string | null | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype/internal/attributes.ts").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export type UpdateOrganizationPayload = typeof UpdateOrganizationPayloadSchema.inferOut;
+export declare const OrganizationAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    name: string;
+    model: "Organization";
+}, {}>;
+export type OrganizationAssociationReference = typeof OrganizationAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=organization.d.ts.map

package/dist/esm/customer/schema/organization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"organization.d.ts","sourceRoot":"","sources":["../../../../src/customer/schema/organization.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AACX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,oBAAoB,qEAAc,CAAC;AAChD,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,4BAA4B;;MAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;AAS/C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;MASD,CAAC;AACtC,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;MAID,CAAC;AAC5C,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;MAGD,CAAC;AAC5C,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,sCAAsC;;;;MAMhD,CAAC;AACJ,MAAM,MAAM,gCAAgC,GAC1C,OAAO,sCAAsC,CAAC,QAAQ,CAAC"}

package/dist/esm/customer/schema/organization.js

@@ -0,0 +1,37 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
+import { MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { generateOrganizationId } from './utils.js';
+export const OrganizationStatus = {
+    ACTIVE: 'active',
+    SUSPENDED: 'suspended',
+};
+export const OrganizationIdSchema = type.string;
+export const OrganizationIdPropertySchema = type({
+    id: OrganizationIdSchema,
+});
+const OrganizationNameSchema = type.string;
+const StatusSchema = type.enumerated(OrganizationStatus.ACTIVE, OrganizationStatus.SUSPENDED);
+export const OrganizationPayloadSchema = type({
+    status: StatusSchema.default(OrganizationStatus.ACTIVE),
+    name: OrganizationNameSchema,
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+})
+    .and(OrganizationIdPropertySchema)
+    .and(MetadataPayloadPropertySchema);
+export const InsertOrganizationPayloadSchema = type({
+    id: OrganizationIdSchema.default(() => generateOrganizationId()),
+    status: StatusSchema.optional(),
+    name: OrganizationNameSchema,
+}).and(UpsertMetadataPayloadPropertySchema);
+export const UpdateOrganizationPayloadSchema = type({
+    status: StatusSchema.or(type.null).optional(),
+    name: OrganizationNameSchema.or(type.null).optional(),
+}).and(UpsertMetadataPayloadPropertySchema);
+export const OrganizationAssociationReferenceSchema = OrganizationIdPropertySchema.and(type({
+    name: type.string,
+    model: "'Organization'",
+}));

package/dist/esm/customer/schema/schema.d.ts

@@ -0,0 +1,4 @@
+export * from '../users/schema.js';
+export * from './organization.js';
+export * from './utils.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/customer/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/customer/schema/schema.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAElC,cAAc,YAAY,CAAC"}

package/dist/esm/customer/schema/schema.js

@@ -0,0 +1,3 @@
+export * from '../users/schema.js';
+export * from './organization.js';
+export * from './utils.js';

package/dist/esm/customer/schema/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const Model: {
+    readonly Organization: {
+        readonly UIDPrefix: "org";
+    };
+    readonly User: {
+        readonly UIDPrefix: "usr";
+    };
+};
+export declare function generateUserId(): string;
+export declare function generateOrganizationId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/customer/schema/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/customer/schema/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,wBAAgB,cAAc,WAE7B;AAED,wBAAgB,sBAAsB,WAErC"}

package/dist/esm/customer/schema/utils.js

@@ -0,0 +1,15 @@
+import KSUID from 'ksuid';
+export const Model = {
+    Organization: {
+        UIDPrefix: 'org',
+    },
+    User: {
+        UIDPrefix: 'usr',
+    },
+};
+export function generateUserId() {
+    return `${Model.User.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateOrganizationId() {
+    return `${Model.Organization.UIDPrefix}_${KSUID.randomSync().string}`;
+}