@hexclave/shared 1.0.0

package/dist/interface/crud/connected-accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-accounts.d.ts","names":[],"sources":["../../../src/interface/crud/connected-accounts.ts"],"mappings":";;;;cAUa,gCAAA,EAID,KAAA,CAJiC,YAAA;;;;GAIjC,KAAA,CAAA,SAAA;;;;;cAEC,oBAAA;;;;;KAcX,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;KACU,oBAAA,GAAuB,UAAA,QAAkB,oBAAA;AAAA,cAGxC,qCAAA,EAED,KAAA,CAFsC,YAAA;;GAEtC,KAAA,CAAA,SAAA;;;cAEC,uCAAA,EAED,KAAA,CAFwC,YAAA;;GAExC,KAAA,CAAA,SAAA;;;cAEC,+BAAA;;;KAQX,KAAA,CAAA,SAAA;;;;;;;;;;;;;;KACU,+BAAA,GAAkC,UAAA,QAAkB,+BAAA"}

package/dist/interface/crud/connected-accounts.js

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../../chunk-BE-pF4vm.js');
+let ______crud_js = require("../../crud.js");
+let ______schema_fields_js = require("../../schema-fields.js");
+
+//#region src/interface/crud/connected-accounts.ts
+const connectedAccountClientReadSchema = (0, ______schema_fields_js.yupObject)({
+	user_id: ______schema_fields_js.userIdOrMeSchema.defined(),
+	provider: ______schema_fields_js.oauthProviderProviderConfigIdSchema.defined(),
+	provider_account_id: ______schema_fields_js.oauthProviderAccountIdSchema.defined()
+}).defined();
+const connectedAccountCrud = (0, ______crud_js.createCrud)({
+	clientReadSchema: connectedAccountClientReadSchema,
+	docs: {
+		clientRead: {
+			summary: "Get a connected account",
+			description: "Retrieves a specific connected account by the user ID and provider account ID.",
+			tags: ["Connected Accounts"]
+		},
+		clientList: {
+			summary: "List connected accounts",
+			description: "Retrieves a list of all connected accounts for a user.",
+			tags: ["Connected Accounts"]
+		}
+	}
+});
+const connectedAccountAccessTokenReadSchema = (0, ______schema_fields_js.yupObject)({ access_token: (0, ______schema_fields_js.yupString)().defined() }).defined();
+const connectedAccountAccessTokenCreateSchema = (0, ______schema_fields_js.yupObject)({ scope: (0, ______schema_fields_js.yupString)().optional() }).defined();
+const connectedAccountAccessTokenCrud = (0, ______crud_js.createCrud)({
+	clientReadSchema: connectedAccountAccessTokenReadSchema,
+	clientCreateSchema: connectedAccountAccessTokenCreateSchema,
+	docs: { clientCreate: { hidden: true } }
+});
+
+//#endregion
+exports.connectedAccountAccessTokenCreateSchema = connectedAccountAccessTokenCreateSchema;
+exports.connectedAccountAccessTokenCrud = connectedAccountAccessTokenCrud;
+exports.connectedAccountAccessTokenReadSchema = connectedAccountAccessTokenReadSchema;
+exports.connectedAccountClientReadSchema = connectedAccountClientReadSchema;
+exports.connectedAccountCrud = connectedAccountCrud;
+//# sourceMappingURL=connected-accounts.js.map

package/dist/interface/crud/connected-accounts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-accounts.js","names":["userIdOrMeSchema","oauthProviderProviderConfigIdSchema","oauthProviderAccountIdSchema"],"sources":["../../../src/interface/crud/connected-accounts.ts"],"sourcesContent":["import { CrudTypeOf, createCrud } from \"../../crud\";\nimport {\n  oauthProviderAccountIdSchema,\n  oauthProviderProviderConfigIdSchema,\n  userIdOrMeSchema,\n  yupObject,\n  yupString\n} from \"../../schema-fields\";\n\n// Connected Account CRUD (for listing/reading connected accounts)\nexport const connectedAccountClientReadSchema = yupObject({\n  user_id: userIdOrMeSchema.defined(),\n  provider: oauthProviderProviderConfigIdSchema.defined(),\n  provider_account_id: oauthProviderAccountIdSchema.defined(),\n}).defined();\n\nexport const connectedAccountCrud = createCrud({\n  clientReadSchema: connectedAccountClientReadSchema,\n  docs: {\n    clientRead: {\n      summary: \"Get a connected account\",\n      description: \"Retrieves a specific connected account by the user ID and provider account ID.\",\n      tags: [\"Connected Accounts\"],\n    },\n    clientList: {\n      summary: \"List connected accounts\",\n      description: \"Retrieves a list of all connected accounts for a user.\",\n      tags: [\"Connected Accounts\"],\n    },\n  },\n});\nexport type ConnectedAccountCrud = CrudTypeOf<typeof connectedAccountCrud>;\n\n// Connected Account Access Token CRUD (for getting access tokens)\nexport const connectedAccountAccessTokenReadSchema = yupObject({\n  access_token: yupString().defined(),\n}).defined();\n\nexport const connectedAccountAccessTokenCreateSchema = yupObject({\n  scope: yupString().optional(),\n}).defined();\n\nexport const connectedAccountAccessTokenCrud = createCrud({\n  clientReadSchema: connectedAccountAccessTokenReadSchema,\n  clientCreateSchema: connectedAccountAccessTokenCreateSchema,\n  docs: {\n    clientCreate: {\n      hidden: true,\n    }\n  },\n});\nexport type ConnectedAccountAccessTokenCrud = CrudTypeOf<typeof connectedAccountAccessTokenCrud>;\n"],"mappings":";;;;;;AAUA,MAAa,yEAA6C;CACxD,SAASA,wCAAiB,SAAS;CACnC,UAAUC,2DAAoC,SAAS;CACvD,qBAAqBC,oDAA6B,SAAS;CAC5D,CAAC,CAAC,SAAS;AAEZ,MAAa,qDAAkC;CAC7C,kBAAkB;CAClB,MAAM;EACJ,YAAY;GACV,SAAS;GACT,aAAa;GACb,MAAM,CAAC,qBAAqB;GAC7B;EACD,YAAY;GACV,SAAS;GACT,aAAa;GACb,MAAM,CAAC,qBAAqB;GAC7B;EACF;CACF,CAAC;AAIF,MAAa,8EAAkD,EAC7D,qDAAyB,CAAC,SAAS,EACpC,CAAC,CAAC,SAAS;AAEZ,MAAa,gFAAoD,EAC/D,8CAAkB,CAAC,UAAU,EAC9B,CAAC,CAAC,SAAS;AAEZ,MAAa,gEAA6C;CACxD,kBAAkB;CAClB,oBAAoB;CACpB,MAAM,EACJ,cAAc,EACZ,QAAQ,MACT,EACF;CACF,CAAC"}

package/dist/interface/crud/contact-channels.d.ts

@@ -0,0 +1,181 @@
+import { CrudSchemaFromOptions, CrudTypeOf } from "../../crud.js";
+import * as yup$1 from "yup";
+
+//#region src/interface/crud/contact-channels.d.ts
+declare const contactChannelsClientReadSchema: yup$1.ObjectSchema<{
+  user_id: string;
+  id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_verified: boolean;
+  is_primary: boolean;
+}, yup$1.AnyObject, {
+  user_id: undefined;
+  id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_verified: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudClientUpdateSchema: yup$1.ObjectSchema<{
+  value: string | undefined;
+  type: "email" | undefined;
+  used_for_auth: boolean | undefined;
+  is_primary: boolean | undefined;
+}, yup$1.AnyObject, {
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudServerUpdateSchema: yup$1.ObjectSchema<{
+  value: string | undefined;
+  type: "email" | undefined;
+  used_for_auth: boolean | undefined;
+  is_primary: boolean | undefined;
+} & {
+  is_verified: boolean | undefined;
+}, yup$1.AnyObject, {
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+  is_verified: undefined;
+}, "">;
+declare const contactChannelsCrudClientCreateSchema: yup$1.ObjectSchema<{
+  user_id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_primary: boolean | undefined;
+}, yup$1.AnyObject, {
+  user_id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudServerCreateSchema: yup$1.ObjectSchema<{
+  user_id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_primary: boolean | undefined;
+} & {
+  is_verified: boolean | undefined;
+}, yup$1.AnyObject, {
+  user_id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+  is_verified: undefined;
+}, "">;
+declare const contactChannelsCrudClientDeleteSchema: yup$1.MixedSchema<{} | undefined, yup$1.AnyObject, undefined, "">;
+declare const contactChannelsCrud: CrudSchemaFromOptions<{
+  clientReadSchema: yup$1.ObjectSchema<{
+    user_id: string;
+    id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_verified: boolean;
+    is_primary: boolean;
+  }, yup$1.AnyObject, {
+    user_id: undefined;
+    id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_verified: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientUpdateSchema: yup$1.ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+  }, yup$1.AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientCreateSchema: yup$1.ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_primary: boolean | undefined;
+  }, yup$1.AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientDeleteSchema: yup$1.MixedSchema<{} | undefined, yup$1.AnyObject, undefined, "">;
+  serverUpdateSchema: yup$1.ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+  } & {
+    is_verified: boolean | undefined;
+  }, yup$1.AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+  }, "">;
+  serverCreateSchema: yup$1.ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_primary: boolean | undefined;
+  } & {
+    is_verified: boolean | undefined;
+  }, yup$1.AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+  }, "">;
+  docs: {
+    clientRead: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientCreate: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientUpdate: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientDelete: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientList: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+  };
+}>;
+type ContactChannelsCrud = CrudTypeOf<typeof contactChannelsCrud>;
+//#endregion
+export { ContactChannelsCrud, contactChannelsClientReadSchema, contactChannelsCrud, contactChannelsCrudClientCreateSchema, contactChannelsCrudClientDeleteSchema, contactChannelsCrudClientUpdateSchema, contactChannelsCrudServerCreateSchema, contactChannelsCrudServerUpdateSchema };
+//# sourceMappingURL=contact-channels.d.ts.map

package/dist/interface/crud/contact-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact-channels.d.ts","names":[],"sources":["../../../src/interface/crud/contact-channels.ts"],"mappings":";;;;cAGa,+BAAA,EAQD,KAAA,CARgC,YAAA;;;;;;;;GAQhC,KAAA,CAAA,SAAA;;;;;;;;;cAEC,qCAAA,EAKD,KAAA,CALsC,YAAA;;;;;GAKtC,KAAA,CAAA,SAAA;;;;;;cAEC,qCAAA,EAEV,KAAA,CAF+C,YAAA;;;;;;;GAE/C,KAAA,CAAA,SAAA;;;;;;;cAEU,qCAAA,EAMD,KAAA,CANsC,YAAA;;;;;;GAMtC,KAAA,CAAA,SAAA;;;;;;;cAEC,qCAAA,EAEV,KAAA,CAF+C,YAAA;;;;;;;;GAE/C,KAAA,CAAA,SAAA;;;;;;;;cAEU,qCAAA,EAAqC,KAAA,CAAA,WAAA,iBAAa,KAAA,CAAb,SAAA;AAAA,cAErC,mBAAA;;;;;;;;;KAkCX,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACU,mBAAA,GAAsB,UAAA,QAAkB,mBAAA"}

package/dist/interface/crud/contact-channels.js

@@ -0,0 +1,76 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../../chunk-BE-pF4vm.js');
+let ______crud_js = require("../../crud.js");
+let ______schema_fields_js = require("../../schema-fields.js");
+
+//#region src/interface/crud/contact-channels.ts
+const contactChannelsClientReadSchema = (0, ______schema_fields_js.yupObject)({
+	user_id: ______schema_fields_js.userIdSchema.defined(),
+	id: ______schema_fields_js.contactChannelIdSchema.defined(),
+	value: ______schema_fields_js.contactChannelValueSchema.defined(),
+	type: ______schema_fields_js.contactChannelTypeSchema.defined(),
+	used_for_auth: ______schema_fields_js.contactChannelUsedForAuthSchema.defined(),
+	is_verified: ______schema_fields_js.contactChannelIsVerifiedSchema.defined(),
+	is_primary: ______schema_fields_js.contactChannelIsPrimarySchema.defined()
+}).defined();
+const contactChannelsCrudClientUpdateSchema = (0, ______schema_fields_js.yupObject)({
+	value: ______schema_fields_js.contactChannelValueSchema.optional(),
+	type: ______schema_fields_js.contactChannelTypeSchema.optional(),
+	used_for_auth: ______schema_fields_js.contactChannelUsedForAuthSchema.optional(),
+	is_primary: ______schema_fields_js.contactChannelIsPrimarySchema.optional()
+}).defined();
+const contactChannelsCrudServerUpdateSchema = contactChannelsCrudClientUpdateSchema.concat((0, ______schema_fields_js.yupObject)({ is_verified: ______schema_fields_js.contactChannelIsVerifiedSchema.optional() }));
+const contactChannelsCrudClientCreateSchema = (0, ______schema_fields_js.yupObject)({
+	user_id: ______schema_fields_js.userIdOrMeSchema.defined(),
+	value: ______schema_fields_js.contactChannelValueSchema.defined(),
+	type: ______schema_fields_js.contactChannelTypeSchema.defined(),
+	used_for_auth: ______schema_fields_js.contactChannelUsedForAuthSchema.defined(),
+	is_primary: ______schema_fields_js.contactChannelIsPrimarySchema.optional()
+}).defined();
+const contactChannelsCrudServerCreateSchema = contactChannelsCrudClientCreateSchema.concat((0, ______schema_fields_js.yupObject)({ is_verified: ______schema_fields_js.contactChannelIsVerifiedSchema.optional() }));
+const contactChannelsCrudClientDeleteSchema = (0, ______schema_fields_js.yupMixed)();
+const contactChannelsCrud = (0, ______crud_js.createCrud)({
+	clientReadSchema: contactChannelsClientReadSchema,
+	clientUpdateSchema: contactChannelsCrudClientUpdateSchema,
+	clientCreateSchema: contactChannelsCrudClientCreateSchema,
+	clientDeleteSchema: contactChannelsCrudClientDeleteSchema,
+	serverUpdateSchema: contactChannelsCrudServerUpdateSchema,
+	serverCreateSchema: contactChannelsCrudServerCreateSchema,
+	docs: {
+		clientRead: {
+			summary: "Get a contact channel",
+			description: "Retrieves a specific contact channel by the user ID and the contact channel ID.",
+			tags: ["Contact Channels"]
+		},
+		clientCreate: {
+			summary: "Create a contact channel",
+			description: "Add a new contact channel for a user.",
+			tags: ["Contact Channels"]
+		},
+		clientUpdate: {
+			summary: "Update a contact channel",
+			description: "Updates an existing contact channel. Only the values provided will be updated.",
+			tags: ["Contact Channels"]
+		},
+		clientDelete: {
+			summary: "Delete a contact channel",
+			description: "Removes a contact channel for a given user.",
+			tags: ["Contact Channels"]
+		},
+		clientList: {
+			summary: "List contact channels",
+			description: "Retrieves a list of all contact channels for a user.",
+			tags: ["Contact Channels"]
+		}
+	}
+});
+
+//#endregion
+exports.contactChannelsClientReadSchema = contactChannelsClientReadSchema;
+exports.contactChannelsCrud = contactChannelsCrud;
+exports.contactChannelsCrudClientCreateSchema = contactChannelsCrudClientCreateSchema;
+exports.contactChannelsCrudClientDeleteSchema = contactChannelsCrudClientDeleteSchema;
+exports.contactChannelsCrudClientUpdateSchema = contactChannelsCrudClientUpdateSchema;
+exports.contactChannelsCrudServerCreateSchema = contactChannelsCrudServerCreateSchema;
+exports.contactChannelsCrudServerUpdateSchema = contactChannelsCrudServerUpdateSchema;
+//# sourceMappingURL=contact-channels.js.map

package/dist/interface/crud/contact-channels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact-channels.js","names":["userIdSchema","contactChannelIdSchema","contactChannelValueSchema","contactChannelTypeSchema","contactChannelUsedForAuthSchema","contactChannelIsVerifiedSchema","contactChannelIsPrimarySchema","userIdOrMeSchema"],"sources":["../../../src/interface/crud/contact-channels.ts"],"sourcesContent":["import { CrudTypeOf, createCrud } from \"../../crud\";\nimport { contactChannelIdSchema, contactChannelIsPrimarySchema, contactChannelIsVerifiedSchema, contactChannelTypeSchema, contactChannelUsedForAuthSchema, contactChannelValueSchema, userIdOrMeSchema, userIdSchema, yupMixed, yupObject } from \"../../schema-fields\";\n\nexport const contactChannelsClientReadSchema = yupObject({\n  user_id: userIdSchema.defined(),\n  id: contactChannelIdSchema.defined(),\n  value: contactChannelValueSchema.defined(),\n  type: contactChannelTypeSchema.defined(),\n  used_for_auth: contactChannelUsedForAuthSchema.defined(),\n  is_verified: contactChannelIsVerifiedSchema.defined(),\n  is_primary: contactChannelIsPrimarySchema.defined(),\n}).defined();\n\nexport const contactChannelsCrudClientUpdateSchema = yupObject({\n  value: contactChannelValueSchema.optional(),\n  type: contactChannelTypeSchema.optional(),\n  used_for_auth: contactChannelUsedForAuthSchema.optional(),\n  is_primary: contactChannelIsPrimarySchema.optional(),\n}).defined();\n\nexport const contactChannelsCrudServerUpdateSchema = contactChannelsCrudClientUpdateSchema.concat(yupObject({\n  is_verified: contactChannelIsVerifiedSchema.optional(),\n}));\n\nexport const contactChannelsCrudClientCreateSchema = yupObject({\n  user_id: userIdOrMeSchema.defined(),\n  value: contactChannelValueSchema.defined(),\n  type: contactChannelTypeSchema.defined(),\n  used_for_auth: contactChannelUsedForAuthSchema.defined(),\n  is_primary: contactChannelIsPrimarySchema.optional(),\n}).defined();\n\nexport const contactChannelsCrudServerCreateSchema = contactChannelsCrudClientCreateSchema.concat(yupObject({\n  is_verified: contactChannelIsVerifiedSchema.optional(),\n}));\n\nexport const contactChannelsCrudClientDeleteSchema = yupMixed();\n\nexport const contactChannelsCrud = createCrud({\n  clientReadSchema: contactChannelsClientReadSchema,\n  clientUpdateSchema: contactChannelsCrudClientUpdateSchema,\n  clientCreateSchema: contactChannelsCrudClientCreateSchema,\n  clientDeleteSchema: contactChannelsCrudClientDeleteSchema,\n  serverUpdateSchema: contactChannelsCrudServerUpdateSchema,\n  serverCreateSchema: contactChannelsCrudServerCreateSchema,\n  docs: {\n    clientRead: {\n      summary: \"Get a contact channel\",\n      description: \"Retrieves a specific contact channel by the user ID and the contact channel ID.\",\n      tags: [\"Contact Channels\"],\n    },\n    clientCreate: {\n      summary: \"Create a contact channel\",\n      description: \"Add a new contact channel for a user.\",\n      tags: [\"Contact Channels\"],\n    },\n    clientUpdate: {\n      summary: \"Update a contact channel\",\n      description: \"Updates an existing contact channel. Only the values provided will be updated.\",\n      tags: [\"Contact Channels\"],\n    },\n    clientDelete: {\n      summary: \"Delete a contact channel\",\n      description: \"Removes a contact channel for a given user.\",\n      tags: [\"Contact Channels\"],\n    },\n    clientList: {\n      summary: \"List contact channels\",\n      description: \"Retrieves a list of all contact channels for a user.\",\n      tags: [\"Contact Channels\"],\n    }\n  }\n});\nexport type ContactChannelsCrud = CrudTypeOf<typeof contactChannelsCrud>;\n"],"mappings":";;;;;;AAGA,MAAa,wEAA4C;CACvD,SAASA,oCAAa,SAAS;CAC/B,IAAIC,8CAAuB,SAAS;CACpC,OAAOC,iDAA0B,SAAS;CAC1C,MAAMC,gDAAyB,SAAS;CACxC,eAAeC,uDAAgC,SAAS;CACxD,aAAaC,sDAA+B,SAAS;CACrD,YAAYC,qDAA8B,SAAS;CACpD,CAAC,CAAC,SAAS;AAEZ,MAAa,8EAAkD;CAC7D,OAAOJ,iDAA0B,UAAU;CAC3C,MAAMC,gDAAyB,UAAU;CACzC,eAAeC,uDAAgC,UAAU;CACzD,YAAYE,qDAA8B,UAAU;CACrD,CAAC,CAAC,SAAS;AAEZ,MAAa,wCAAwC,sCAAsC,6CAAiB,EAC1G,aAAaD,sDAA+B,UAAU,EACvD,CAAC,CAAC;AAEH,MAAa,8EAAkD;CAC7D,SAASE,wCAAiB,SAAS;CACnC,OAAOL,iDAA0B,SAAS;CAC1C,MAAMC,gDAAyB,SAAS;CACxC,eAAeC,uDAAgC,SAAS;CACxD,YAAYE,qDAA8B,UAAU;CACrD,CAAC,CAAC,SAAS;AAEZ,MAAa,wCAAwC,sCAAsC,6CAAiB,EAC1G,aAAaD,sDAA+B,UAAU,EACvD,CAAC,CAAC;AAEH,MAAa,8EAAkD;AAE/D,MAAa,oDAAiC;CAC5C,kBAAkB;CAClB,oBAAoB;CACpB,oBAAoB;CACpB,oBAAoB;CACpB,oBAAoB;CACpB,oBAAoB;CACpB,MAAM;EACJ,YAAY;GACV,SAAS;GACT,aAAa;GACb,MAAM,CAAC,mBAAmB;GAC3B;EACD,cAAc;GACZ,SAAS;GACT,aAAa;GACb,MAAM,CAAC,mBAAmB;GAC3B;EACD,cAAc;GACZ,SAAS;GACT,aAAa;GACb,MAAM,CAAC,mBAAmB;GAC3B;EACD,cAAc;GACZ,SAAS;GACT,aAAa;GACb,MAAM,CAAC,mBAAmB;GAC3B;EACD,YAAY;GACV,SAAS;GACT,aAAa;GACb,MAAM,CAAC,mBAAmB;GAC3B;EACF;CACF,CAAC"}

package/dist/interface/crud/current-user.d.ts

@@ -0,0 +1,285 @@
+import { CrudSchemaFromOptions, CrudTypeOf } from "../../crud.js";
+import * as yup$1 from "yup";
+
+//#region src/interface/crud/current-user.d.ts
+declare const currentUserCrud: CrudSchemaFromOptions<{
+  clientReadSchema: yup$1.ObjectSchema<{
+    selected_team_id: string | null;
+    is_anonymous: boolean;
+    is_restricted: boolean;
+    restricted_reason: {
+      type: "anonymous" | "email_not_verified" | "restricted_by_administrator";
+    } | null;
+    requires_totp_mfa: boolean;
+    display_name: string | null;
+    client_metadata: {} | null;
+    client_read_only_metadata: {} | null;
+    id: string;
+    primary_email: string | null;
+    primary_email_verified: boolean;
+    profile_image_url: string | null;
+    signed_up_at_millis: number;
+    has_password: boolean;
+    otp_auth_enabled: boolean;
+    passkey_auth_enabled: boolean;
+    restricted_by_admin: boolean;
+    restricted_by_admin_reason: string | null;
+    oauth_providers: {
+      email?: string | null | undefined;
+      id: string;
+      account_id: string;
+    }[];
+    auth_with_email: boolean;
+  } & {
+    selected_team: {
+      client_metadata?: {} | null | undefined;
+      client_read_only_metadata?: {} | null | undefined;
+      display_name: string;
+      id: string;
+      profile_image_url: string | null;
+    } | null;
+  }, yup$1.AnyObject, {
+    id: undefined;
+    primary_email: undefined;
+    primary_email_verified: undefined;
+    primary_email_auth_enabled: undefined;
+    display_name: undefined;
+    selected_team: {
+      id: undefined;
+      display_name: undefined;
+      profile_image_url: undefined;
+      client_metadata: undefined;
+      client_read_only_metadata: undefined;
+    };
+    selected_team_id: undefined;
+    profile_image_url: undefined;
+    signed_up_at_millis: undefined;
+    has_password: undefined;
+    otp_auth_enabled: undefined;
+    passkey_auth_enabled: undefined;
+    client_metadata: undefined;
+    client_read_only_metadata: undefined;
+    server_metadata: undefined;
+    last_active_at_millis: undefined;
+    is_anonymous: undefined;
+    is_restricted: undefined;
+    restricted_reason: {
+      type: undefined;
+    };
+    restricted_by_admin: undefined;
+    restricted_by_admin_reason: undefined;
+    restricted_by_admin_private_details: undefined;
+    country_code: undefined;
+    risk_scores: {
+      sign_up: {
+        bot: undefined;
+        free_trial_abuse: undefined;
+      };
+    };
+    oauth_providers: undefined;
+    auth_with_email: undefined;
+    requires_totp_mfa: undefined;
+  }, "">;
+  serverReadSchema: yup$1.ObjectSchema<{
+    id: string;
+    primary_email: string | null;
+    primary_email_verified: boolean;
+    primary_email_auth_enabled: boolean;
+    display_name: string | null;
+    selected_team: {
+      client_metadata?: {} | null | undefined;
+      client_read_only_metadata?: {} | null | undefined;
+      server_metadata?: {} | null | undefined;
+      display_name: string;
+      id: string;
+      profile_image_url: string | null;
+      created_at_millis: number;
+    } | null;
+    selected_team_id: string | null;
+    profile_image_url: string | null;
+    signed_up_at_millis: number;
+    has_password: boolean;
+    otp_auth_enabled: boolean;
+    passkey_auth_enabled: boolean;
+    client_metadata: {} | null;
+    client_read_only_metadata: {} | null;
+    server_metadata: {} | null;
+    last_active_at_millis: number;
+    is_anonymous: boolean;
+    is_restricted: boolean;
+    restricted_reason: {
+      type: "anonymous" | "email_not_verified" | "restricted_by_administrator";
+    } | null;
+    restricted_by_admin: boolean;
+    restricted_by_admin_reason: string | null;
+    restricted_by_admin_private_details: string | null;
+    country_code: string | null;
+    risk_scores: {
+      sign_up: {
+        bot: number;
+        free_trial_abuse: number;
+      };
+    };
+    oauth_providers: {
+      email?: string | null | undefined;
+      id: string;
+      account_id: string;
+    }[];
+    auth_with_email: boolean;
+    requires_totp_mfa: boolean;
+  }, yup$1.AnyObject, {
+    id: undefined;
+    primary_email: undefined;
+    primary_email_verified: undefined;
+    primary_email_auth_enabled: undefined;
+    display_name: undefined;
+    selected_team: {
+      id: undefined;
+      display_name: undefined;
+      profile_image_url: undefined;
+      client_metadata: undefined;
+      client_read_only_metadata: undefined;
+      created_at_millis: undefined;
+      server_metadata: undefined;
+    };
+    selected_team_id: undefined;
+    profile_image_url: undefined;
+    signed_up_at_millis: undefined;
+    has_password: undefined;
+    otp_auth_enabled: undefined;
+    passkey_auth_enabled: undefined;
+    client_metadata: undefined;
+    client_read_only_metadata: undefined;
+    server_metadata: undefined;
+    last_active_at_millis: undefined;
+    is_anonymous: undefined;
+    is_restricted: undefined;
+    restricted_reason: {
+      type: undefined;
+    };
+    restricted_by_admin: undefined;
+    restricted_by_admin_reason: undefined;
+    restricted_by_admin_private_details: undefined;
+    country_code: undefined;
+    risk_scores: {
+      sign_up: {
+        bot: undefined;
+        free_trial_abuse: undefined;
+      };
+    };
+    oauth_providers: undefined;
+    auth_with_email: undefined;
+    requires_totp_mfa: undefined;
+  }, "">;
+  clientUpdateSchema: yup$1.ObjectSchema<{
+    selected_team_id: string | null | undefined;
+    display_name: string | null | undefined;
+    client_metadata: {} | null | undefined;
+    primary_email: string | null | undefined;
+    profile_image_url: string | null | undefined;
+    otp_auth_enabled: boolean | undefined;
+    passkey_auth_enabled: boolean | undefined;
+    totp_secret_base64: string | null | undefined;
+  }, yup$1.AnyObject, {
+    display_name: undefined;
+    profile_image_url: undefined;
+    client_metadata: undefined;
+    client_read_only_metadata: undefined;
+    server_metadata: undefined;
+    primary_email: undefined;
+    primary_email_verified: undefined;
+    primary_email_auth_enabled: undefined;
+    passkey_auth_enabled: undefined;
+    password: undefined;
+    password_hash: undefined;
+    otp_auth_enabled: undefined;
+    totp_secret_base64: undefined;
+    selected_team_id: undefined;
+    is_anonymous: undefined;
+    restricted_by_admin: undefined;
+    restricted_by_admin_reason: undefined;
+    restricted_by_admin_private_details: undefined;
+    country_code: undefined;
+    risk_scores: {
+      sign_up: {
+        bot: undefined;
+        free_trial_abuse: undefined;
+      };
+    };
+  }, "">;
+  serverUpdateSchema: yup$1.ObjectSchema<{
+    display_name: string | null | undefined;
+    profile_image_url: string | null | undefined;
+    client_metadata: {} | null | undefined;
+    client_read_only_metadata: {} | null | undefined;
+    server_metadata: {} | null | undefined;
+    primary_email: string | null | undefined;
+    primary_email_verified: boolean | undefined;
+    primary_email_auth_enabled: boolean | undefined;
+    passkey_auth_enabled: boolean | undefined;
+    password: string | null | undefined;
+    password_hash: string | undefined;
+    otp_auth_enabled: boolean | undefined;
+    totp_secret_base64: string | null | undefined;
+    selected_team_id: string | null | undefined;
+    is_anonymous: boolean | undefined;
+    restricted_by_admin: boolean | undefined;
+    restricted_by_admin_reason: string | null | undefined;
+    restricted_by_admin_private_details: string | null | undefined;
+    country_code: string | null | undefined;
+    risk_scores: {
+      sign_up: {
+        bot: number;
+        free_trial_abuse: number;
+      };
+    } | undefined;
+  }, yup$1.AnyObject, {
+    display_name: undefined;
+    profile_image_url: undefined;
+    client_metadata: undefined;
+    client_read_only_metadata: undefined;
+    server_metadata: undefined;
+    primary_email: undefined;
+    primary_email_verified: undefined;
+    primary_email_auth_enabled: undefined;
+    passkey_auth_enabled: undefined;
+    password: undefined;
+    password_hash: undefined;
+    otp_auth_enabled: undefined;
+    totp_secret_base64: undefined;
+    selected_team_id: undefined;
+    is_anonymous: undefined;
+    restricted_by_admin: undefined;
+    restricted_by_admin_reason: undefined;
+    restricted_by_admin_private_details: undefined;
+    country_code: undefined;
+    risk_scores: {
+      sign_up: {
+        bot: undefined;
+        free_trial_abuse: undefined;
+      };
+    };
+  }, "">;
+  clientDeleteSchema: yup$1.MixedSchema<{} | undefined, yup$1.AnyObject, undefined, "">;
+  docs: {
+    clientRead: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientUpdate: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientDelete: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+  };
+}>;
+type CurrentUserCrud = CrudTypeOf<typeof currentUserCrud>;
+//#endregion
+export { CurrentUserCrud, currentUserCrud };
+//# sourceMappingURL=current-user.d.ts.map

package/dist/interface/crud/current-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-user.d.ts","names":[],"sources":["../../../src/interface/crud/current-user.ts"],"mappings":";;;;cA+Ca,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuBX,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACU,eAAA,GAAkB,UAAA,QAAkB,eAAA"}

package/dist/interface/crud/current-user.js

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../../chunk-BE-pF4vm.js');
+let ______crud_js = require("../../crud.js");
+let ______schema_fields_js = require("../../schema-fields.js");
+let __teams_js = require("./teams.js");
+let __users_js = require("./users.js");
+
+//#region src/interface/crud/current-user.ts
+const clientUpdateSchema = __users_js.usersCrudServerUpdateSchema.pick([
+	"display_name",
+	"profile_image_url",
+	"client_metadata",
+	"selected_team_id",
+	"totp_secret_base64",
+	"otp_auth_enabled",
+	"passkey_auth_enabled",
+	"primary_email"
+]).defined();
+const serverUpdateSchema = __users_js.usersCrudServerUpdateSchema;
+const clientReadSchema = __users_js.usersCrudServerReadSchema.pick([
+	"id",
+	"primary_email",
+	"primary_email_verified",
+	"display_name",
+	"client_metadata",
+	"client_read_only_metadata",
+	"profile_image_url",
+	"signed_up_at_millis",
+	"has_password",
+	"auth_with_email",
+	"oauth_providers",
+	"selected_team_id",
+	"requires_totp_mfa",
+	"otp_auth_enabled",
+	"passkey_auth_enabled",
+	"is_anonymous",
+	"is_restricted",
+	"restricted_reason",
+	"restricted_by_admin",
+	"restricted_by_admin_reason"
+]).concat((0, ______schema_fields_js.yupObject)({ selected_team: __teams_js.teamsCrudClientReadSchema.nullable().defined() })).defined();
+const serverReadSchema = __users_js.usersCrudServerReadSchema.defined();
+const clientDeleteSchema = __users_js.usersCrudServerDeleteSchema;
+const currentUserCrud = (0, ______crud_js.createCrud)({
+	clientReadSchema,
+	serverReadSchema,
+	clientUpdateSchema,
+	serverUpdateSchema,
+	clientDeleteSchema,
+	docs: {
+		clientRead: {
+			summary: "Get current user",
+			description: "Gets the currently authenticated user.",
+			tags: ["Users"]
+		},
+		clientUpdate: {
+			summary: "Update current user",
+			description: "Updates the currently authenticated user. Only the values provided will be updated.",
+			tags: ["Users"]
+		},
+		clientDelete: {
+			summary: "Delete current user",
+			description: "Deletes the currently authenticated user. Use this with caution.",
+			tags: ["Users"]
+		}
+	}
+});
+
+//#endregion
+exports.currentUserCrud = currentUserCrud;
+//# sourceMappingURL=current-user.js.map