@keimelion/sdk 0.0.0-stage → 0.1.0

package/dist/error-B-yLf6aF.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+
+declare const loginRequestSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    password: z.ZodString;
+}, z.core.$strip>;
+type LoginRequestInput = z.input<typeof loginRequestSchema>;
+type LoginRequestParsed = z.output<typeof loginRequestSchema>;
+declare const loginResponseSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    user: z.ZodObject<{
+        id: z.ZodGUID;
+        email: z.ZodString;
+        username: z.ZodNullable<z.ZodString>;
+        authProvider: z.ZodEnum<{
+            email: "email";
+            google: "google";
+        }>;
+        role: z.ZodEnum<{
+            user: "user";
+            moderator: "moderator";
+            admin: "admin";
+        }>;
+        avatarImageId: z.ZodNullable<z.ZodGUID>;
+        avatar: z.ZodNullable<z.ZodObject<{
+            id: z.ZodGUID;
+            hash: z.ZodString;
+            mime: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+            urls: z.ZodObject<{
+                sm: z.ZodURL;
+                md: z.ZodURL;
+                lg: z.ZodURL;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        isCgvAccepted: z.ZodBoolean;
+        cgvAcceptedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        isMarketingOptedIn: z.ZodBoolean;
+        defaultCurrency: z.ZodEnum<{
+            readonly EUR: "EUR";
+            readonly USD: "USD";
+            readonly GBP: "GBP";
+            readonly CHF: "CHF";
+            readonly CAD: "CAD";
+            readonly AUD: "AUD";
+            readonly JPY: "JPY";
+        }>;
+        emailVerifiedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        lastActiveAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+        updatedAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type LoginResponseInput = z.input<typeof loginResponseSchema>;
+type LoginResponseParsed = z.output<typeof loginResponseSchema>;
+
+declare const refreshRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+type RefreshRequestInput = z.input<typeof refreshRequestSchema>;
+type RefreshRequestParsed = z.output<typeof refreshRequestSchema>;
+declare const refreshResponseSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+type RefreshResponseInput = z.input<typeof refreshResponseSchema>;
+type RefreshResponseParsed = z.output<typeof refreshResponseSchema>;
+
+declare const logoutRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type LogoutRequestInput = z.input<typeof logoutRequestSchema>;
+type LogoutRequestParsed = z.output<typeof logoutRequestSchema>;
+declare const logoutResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type LogoutResponseInput = z.input<typeof logoutResponseSchema>;
+type LogoutResponseParsed = z.output<typeof logoutResponseSchema>;
+
+declare const registerRequestSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    password: z.ZodString;
+    username: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    isMarketingOptedIn: z.ZodDefault<z.ZodBoolean>;
+    defaultCurrency: z.ZodOptional<z.ZodEnum<{
+        readonly EUR: "EUR";
+        readonly USD: "USD";
+        readonly GBP: "GBP";
+        readonly CHF: "CHF";
+        readonly CAD: "CAD";
+        readonly AUD: "AUD";
+        readonly JPY: "JPY";
+    }>>;
+}, z.core.$strip>;
+type RegisterRequestInput = z.input<typeof registerRequestSchema>;
+type RegisterRequestParsed = z.output<typeof registerRequestSchema>;
+declare const registerResponseSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodGUID;
+        email: z.ZodString;
+        username: z.ZodNullable<z.ZodString>;
+        authProvider: z.ZodEnum<{
+            email: "email";
+            google: "google";
+        }>;
+        role: z.ZodEnum<{
+            user: "user";
+            moderator: "moderator";
+            admin: "admin";
+        }>;
+        avatarImageId: z.ZodNullable<z.ZodGUID>;
+        avatar: z.ZodNullable<z.ZodObject<{
+            id: z.ZodGUID;
+            hash: z.ZodString;
+            mime: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+            urls: z.ZodObject<{
+                sm: z.ZodURL;
+                md: z.ZodURL;
+                lg: z.ZodURL;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        isCgvAccepted: z.ZodBoolean;
+        cgvAcceptedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        isMarketingOptedIn: z.ZodBoolean;
+        defaultCurrency: z.ZodEnum<{
+            readonly EUR: "EUR";
+            readonly USD: "USD";
+            readonly GBP: "GBP";
+            readonly CHF: "CHF";
+            readonly CAD: "CAD";
+            readonly AUD: "AUD";
+            readonly JPY: "JPY";
+        }>;
+        emailVerifiedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        lastActiveAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+        createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+        updatedAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+    }, z.core.$strip>;
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+type RegisterResponseInput = z.input<typeof registerResponseSchema>;
+type RegisterResponseParsed = z.output<typeof registerResponseSchema>;
+
+declare const verifyEmailRequestSchema: z.ZodObject<{
+    token: z.ZodGUID;
+}, z.core.$strip>;
+type VerifyEmailRequestInput = z.input<typeof verifyEmailRequestSchema>;
+type VerifyEmailRequestParsed = z.output<typeof verifyEmailRequestSchema>;
+declare const verifyEmailResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type VerifyEmailResponseInput = z.input<typeof verifyEmailResponseSchema>;
+type VerifyEmailResponseParsed = z.output<typeof verifyEmailResponseSchema>;
+
+declare const forgotPasswordRequestSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+}, z.core.$strip>;
+type ForgotPasswordRequestInput = z.input<typeof forgotPasswordRequestSchema>;
+type ForgotPasswordRequestParsed = z.output<typeof forgotPasswordRequestSchema>;
+declare const forgotPasswordResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type ForgotPasswordResponseInput = z.input<typeof forgotPasswordResponseSchema>;
+type ForgotPasswordResponseParsed = z.output<typeof forgotPasswordResponseSchema>;
+
+declare const resetPasswordRequestSchema: z.ZodObject<{
+    passwordResetToken: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+type ResetPasswordRequestInput = z.input<typeof resetPasswordRequestSchema>;
+type ResetPasswordRequestParsed = z.output<typeof resetPasswordRequestSchema>;
+declare const resetPasswordResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type ResetPasswordResponseInput = z.input<typeof resetPasswordResponseSchema>;
+type ResetPasswordResponseParsed = z.output<typeof resetPasswordResponseSchema>;
+
+declare const VALIDATION_ROOT_PATH = "<root>";
+declare const validationIssueSchema: z.ZodObject<{
+    path: z.ZodString;
+    message: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>;
+type ValidationIssueInput = z.input<typeof validationIssueSchema>;
+type ValidationIssueParsed = z.output<typeof validationIssueSchema>;
+declare const validationErrorMetadataSchema: z.ZodObject<{
+    issues: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ValidationErrorMetadataInput = z.input<typeof validationErrorMetadataSchema>;
+type ValidationErrorMetadataParsed = z.output<typeof validationErrorMetadataSchema>;
+declare const apiErrorBodySchema: z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type ApiErrorBodyInput = z.input<typeof apiErrorBodySchema>;
+type ApiErrorBodyParsed = z.output<typeof apiErrorBodySchema>;
+
+export { apiErrorBodySchema as G, forgotPasswordRequestSchema as H, forgotPasswordResponseSchema as I, loginRequestSchema as J, loginResponseSchema as K, logoutRequestSchema as M, logoutResponseSchema as N, refreshRequestSchema as O, refreshResponseSchema as P, registerRequestSchema as Q, registerResponseSchema as S, resetPasswordRequestSchema as T, resetPasswordResponseSchema as U, validationErrorMetadataSchema as W, validationIssueSchema as X, verifyEmailRequestSchema as Y, verifyEmailResponseSchema as Z, VALIDATION_ROOT_PATH as y };
+export type { ApiErrorBodyInput as A, ValidationErrorMetadataParsed as B, ValidationIssueInput as C, VerifyEmailRequestParsed as D, VerifyEmailResponseInput as E, ForgotPasswordRequestInput as F, LoginRequestInput as L, RegisterRequestInput as R, VerifyEmailRequestInput as V, RegisterResponseParsed as a, VerifyEmailResponseParsed as b, LoginResponseParsed as c, RefreshRequestInput as d, RefreshResponseParsed as e, LogoutRequestInput as f, LogoutResponseParsed as g, ForgotPasswordResponseParsed as h, ResetPasswordRequestInput as i, ResetPasswordResponseParsed as j, ValidationIssueParsed as k, ApiErrorBodyParsed as l, ForgotPasswordRequestParsed as m, ForgotPasswordResponseInput as n, LoginRequestParsed as o, LoginResponseInput as p, LogoutRequestParsed as q, LogoutResponseInput as r, RefreshRequestParsed as s, RefreshResponseInput as t, RegisterRequestParsed as u, RegisterResponseInput as v, ResetPasswordRequestParsed as w, ResetPasswordResponseInput as x, ValidationErrorMetadataInput as z };

package/dist/error-code-DzfCEXrl.d.ts

@@ -0,0 +1,78 @@
+declare const HttpMethod: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+    readonly OPTIONS: "OPTIONS";
+};
+type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];
+declare const HttpHeader: {
+    readonly ACCEPT: "Accept";
+    readonly CONTENT_TYPE: "Content-Type";
+    readonly AUTHORIZATION: "Authorization";
+};
+type HttpHeader = (typeof HttpHeader)[keyof typeof HttpHeader];
+declare const HttpStatus: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+};
+type HttpStatus = (typeof HttpStatus)[keyof typeof HttpStatus];
+
+declare const ErrorCode: {
+    readonly BAD_REQUEST: "BAD_REQUEST";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly EMAIL_NOT_VERIFIED: "EMAIL_NOT_VERIFIED";
+    readonly ACCOUNT_BANNED: "ACCOUNT_BANNED";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly CONFLICT: "CONFLICT";
+    readonly DUPLICATE_SHOP_FOR_ITEM: "DUPLICATE_SHOP_FOR_ITEM";
+    readonly SLUG_GENERATION_EXHAUSTED: "SLUG_GENERATION_EXHAUSTED";
+    readonly CATEGORY_NOT_FOUND: "CATEGORY_NOT_FOUND";
+    readonly CATEGORY_MAX_DEPTH_EXCEEDED: "CATEGORY_MAX_DEPTH_EXCEEDED";
+    readonly CATEGORY_CYCLE_DETECTED: "CATEGORY_CYCLE_DETECTED";
+    readonly TAG_NOT_FOUND: "TAG_NOT_FOUND";
+    readonly TAG_INVALID_NAME: "TAG_INVALID_NAME";
+    readonly UNPROCESSABLE_ENTITY: "UNPROCESSABLE_ENTITY";
+    readonly NO_FIELDS_TO_UPDATE: "NO_FIELDS_TO_UPDATE";
+    readonly RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
+    readonly USER_CREATION_FAILED: "USER_CREATION_FAILED";
+    readonly USER_UPDATE_FAILED: "USER_UPDATE_FAILED";
+    readonly ACCOUNT_DELETION_FAILED: "ACCOUNT_DELETION_FAILED";
+    readonly LOGOUT_FAILED: "LOGOUT_FAILED";
+    readonly INVALID_RESET_TOKEN: "INVALID_RESET_TOKEN";
+    readonly INVALID_REFRESH_TOKEN: "INVALID_REFRESH_TOKEN";
+    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
+    readonly INVALID_OPERATION: "INVALID_OPERATION";
+    readonly FEEDBACK_CREATION_FAILED: "FEEDBACK_CREATION_FAILED";
+    readonly FEEDBACK_NOT_FOUND: "FEEDBACK_NOT_FOUND";
+    readonly INVALID_IMAGE: "INVALID_IMAGE";
+    readonly INVALID_IMAGE_TYPE: "INVALID_IMAGE_TYPE";
+    readonly PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+    readonly IMAGE_AND_CLEAR_CONFLICT: "IMAGE_AND_CLEAR_CONFLICT";
+    readonly COLLAB_SELF_INVITE: "COLLAB_SELF_INVITE";
+    readonly COLLAB_ALREADY_MEMBER: "COLLAB_ALREADY_MEMBER";
+    readonly COLLAB_INVITE_NOT_FOUND: "COLLAB_INVITE_NOT_FOUND";
+    readonly COLLAB_INVITE_EXPIRED: "COLLAB_INVITE_EXPIRED";
+    readonly COLLAB_INVITE_ALREADY_RESOLVED: "COLLAB_INVITE_ALREADY_RESOLVED";
+    readonly COLLAB_EMAIL_MISMATCH: "COLLAB_EMAIL_MISMATCH";
+    readonly RESERVATION_TOKEN_INVALID: "RESERVATION_TOKEN_INVALID";
+    readonly RESERVATION_REQUIRES_RESERVER_NAME: "RESERVATION_REQUIRES_RESERVER_NAME";
+    readonly RESERVATION_INCONSISTENT_INTENT: "RESERVATION_INCONSISTENT_INTENT";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+export { ErrorCode as E, HttpMethod as H, HttpHeader as a, HttpStatus as b };

package/dist/schemas/index.d.ts

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+import { SupportedCurrency } from '../enums/index.js';
+export { A as ApiErrorBodyInput, l as ApiErrorBodyParsed, F as ForgotPasswordRequestInput, m as ForgotPasswordRequestParsed, n as ForgotPasswordResponseInput, h as ForgotPasswordResponseParsed, L as LoginRequestInput, o as LoginRequestParsed, p as LoginResponseInput, c as LoginResponseParsed, f as LogoutRequestInput, q as LogoutRequestParsed, r as LogoutResponseInput, g as LogoutResponseParsed, d as RefreshRequestInput, s as RefreshRequestParsed, t as RefreshResponseInput, e as RefreshResponseParsed, R as RegisterRequestInput, u as RegisterRequestParsed, v as RegisterResponseInput, a as RegisterResponseParsed, i as ResetPasswordRequestInput, w as ResetPasswordRequestParsed, x as ResetPasswordResponseInput, j as ResetPasswordResponseParsed, y as VALIDATION_ROOT_PATH, z as ValidationErrorMetadataInput, B as ValidationErrorMetadataParsed, C as ValidationIssueInput, k as ValidationIssueParsed, V as VerifyEmailRequestInput, D as VerifyEmailRequestParsed, E as VerifyEmailResponseInput, b as VerifyEmailResponseParsed, G as apiErrorBodySchema, H as forgotPasswordRequestSchema, I as forgotPasswordResponseSchema, J as loginRequestSchema, K as loginResponseSchema, M as logoutRequestSchema, N as logoutResponseSchema, O as refreshRequestSchema, P as refreshResponseSchema, Q as registerRequestSchema, S as registerResponseSchema, T as resetPasswordRequestSchema, U as resetPasswordResponseSchema, W as validationErrorMetadataSchema, X as validationIssueSchema, Y as verifyEmailRequestSchema, Z as verifyEmailResponseSchema } from '../error-B-yLf6aF.js';
+
+declare const DEFAULT_DISPLAY_CURRENCY: SupportedCurrency;
+declare const supportedCurrencyEnum: z.ZodEnum<{
+    readonly EUR: "EUR";
+    readonly USD: "USD";
+    readonly GBP: "GBP";
+    readonly CHF: "CHF";
+    readonly CAD: "CAD";
+    readonly AUD: "AUD";
+    readonly JPY: "JPY";
+}>;
+type SupportedCurrencyInput = z.input<typeof supportedCurrencyEnum>;
+type SupportedCurrencyParsed = z.output<typeof supportedCurrencyEnum>;
+declare const displayCurrencyQuerySchema: z.ZodObject<{
+    currency: z.ZodOptional<z.ZodEnum<{
+        readonly EUR: "EUR";
+        readonly USD: "USD";
+        readonly GBP: "GBP";
+        readonly CHF: "CHF";
+        readonly CAD: "CAD";
+        readonly AUD: "AUD";
+        readonly JPY: "JPY";
+    }>>;
+}, z.core.$strip>;
+type DisplayCurrencyQueryInput = z.input<typeof displayCurrencyQuerySchema>;
+type DisplayCurrencyQueryParsed = z.output<typeof displayCurrencyQuerySchema>;
+
+declare const emailSchema: z.ZodPipe<z.ZodString, z.ZodEmail>;
+type EmailInput = z.input<typeof emailSchema>;
+type EmailParsed = z.output<typeof emailSchema>;
+
+declare const imageUrlsSchema: z.ZodObject<{
+    sm: z.ZodURL;
+    md: z.ZodURL;
+    lg: z.ZodURL;
+}, z.core.$strip>;
+type ImageUrlsInput = z.input<typeof imageUrlsSchema>;
+type ImageUrlsParsed = z.output<typeof imageUrlsSchema>;
+declare const imageDetailSchema: z.ZodObject<{
+    id: z.ZodGUID;
+    hash: z.ZodString;
+    mime: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+    urls: z.ZodObject<{
+        sm: z.ZodURL;
+        md: z.ZodURL;
+        lg: z.ZodURL;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type ImageDetailInput = z.input<typeof imageDetailSchema>;
+type ImageDetailParsed = z.output<typeof imageDetailSchema>;
+
+declare const messageResponseSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+type MessageResponseInput = z.input<typeof messageResponseSchema>;
+type MessageResponseParsed = z.output<typeof messageResponseSchema>;
+
+declare const DUPLICATE_SHOP_IN_SOURCES_MESSAGE = "This shop is already used by another source of this item.";
+declare const SLUG_GENERATION_EXHAUSTED_MESSAGE = "Could not generate a unique slug, please retry with a different title.";
+declare const MAX_CATEGORY_DEPTH = 3;
+declare const CATEGORY_NOT_FOUND_MESSAGE = "Category not found";
+declare const CATEGORY_MAX_DEPTH_EXCEEDED_MESSAGE: string;
+declare const CATEGORY_CYCLE_DETECTED_MESSAGE = "Category parent cannot create a cycle in the hierarchy";
+declare const TAG_NOT_FOUND_MESSAGE = "Tag not found";
+declare const TAG_INVALID_NAME_MESSAGE = "Tag name must contain at least one letter or digit after normalization";
+declare const FEEDBACK_NOT_FOUND_MESSAGE = "Feedback not found";
+declare const COLLAB_SELF_INVITE_MESSAGE = "You cannot invite yourself to collaborate on your own list";
+declare const COLLAB_ALREADY_MEMBER_MESSAGE = "This list already has an active editor invitation or collaborator";
+declare const COLLAB_INVITE_NOT_FOUND_MESSAGE = "Invitation not found";
+declare const COLLAB_INVITE_EXPIRED_MESSAGE = "This invitation has expired";
+declare const COLLAB_INVITE_ALREADY_RESOLVED_MESSAGE = "This invitation has already been accepted or revoked";
+declare const COLLAB_EMAIL_MISMATCH_MESSAGE = "This invitation was issued to a different email address";
+declare const RESERVATION_TOKEN_INVALID_MESSAGE = "The reservation token is invalid for this reservation";
+declare const RESERVATION_REQUIRES_RESERVER_NAME_MESSAGE = "reserverName is required when reserving without an account";
+declare const RESERVATION_INCONSISTENT_INTENT_MESSAGE = "Only the list owner may reserve on behalf of someone else (reserverName)";
+
+declare const noContentResponseSchema: z.ZodUndefined;
+type NoContentResponseInput = z.input<typeof noContentResponseSchema>;
+type NoContentResponseParsed = z.output<typeof noContentResponseSchema>;
+
+declare const PAGINATION_DEFAULT_PAGE = 1;
+declare const PAGINATION_DEFAULT_LIMIT = 20;
+declare const PAGINATION_MAX_LIMIT = 100;
+declare const paginationQuerySchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type PaginationQueryInput = z.input<typeof paginationQuerySchema>;
+type PaginationQueryParsed = z.output<typeof paginationQuerySchema>;
+declare const paginationMetaSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    total: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip>;
+type PaginationMetaInput = z.input<typeof paginationMetaSchema>;
+type PaginationMetaParsed = z.output<typeof paginationMetaSchema>;
+interface PaginatedResponse<TItem> {
+    items: TItem[];
+    pagination: PaginationMetaParsed;
+}
+type PaginatedResponseSchema<TItemSchema extends z.ZodType> = z.ZodObject<{
+    items: z.ZodArray<TItemSchema>;
+    pagination: typeof paginationMetaSchema;
+}>;
+declare function paginatedResponseSchema<TItemSchema extends z.ZodType>(itemSchema: TItemSchema): PaginatedResponseSchema<TItemSchema>;
+type PaginatedResponseInput<TItemSchema extends z.ZodType> = z.input<PaginatedResponseSchema<TItemSchema>>;
+type PaginatedResponseParsed<TItemSchema extends z.ZodType> = z.output<PaginatedResponseSchema<TItemSchema>>;
+
+declare const MIN_PASSWORD_LENGTH = 8;
+declare const MAX_PASSWORD_LENGTH = 72;
+declare const passwordSchema: z.ZodString;
+type PasswordInput = z.input<typeof passwordSchema>;
+type PasswordParsed = z.output<typeof passwordSchema>;
+
+interface SlugSchemaOptions {
+    min: number;
+    max: number;
+    example: string;
+}
+declare function createSlugSchema({ min, max, example }: SlugSchemaOptions): z.ZodString;
+type SlugInput = z.input<ReturnType<typeof createSlugSchema>>;
+type SlugParsed = z.output<ReturnType<typeof createSlugSchema>>;
+
+declare const SORT_DIRECTIONS: readonly ["asc", "desc"];
+type SortDirection = (typeof SORT_DIRECTIONS)[number];
+interface SortInput<TField extends string> {
+    field: TField;
+    direction: SortDirection;
+}
+declare function sortQuerySchema<TField extends string>(allowedFields: readonly [TField, ...TField[]]): z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
+    field: string;
+    direction: string;
+}, string>>, z.ZodObject<{
+    field: z.ZodEnum<{ [k_1 in TField]: k_1; } extends infer T ? { [k in keyof T]: T[k]; } : never>;
+    direction: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>>>;
+type SortQueryInput<TField extends string> = z.input<ReturnType<typeof sortQuerySchema<TField>>>;
+type SortQueryParsed<TField extends string> = z.output<ReturnType<typeof sortQuerySchema<TField>>>;
+
+declare const sortOrderSchema: z.ZodNumber;
+type SortOrderInput = z.input<typeof sortOrderSchema>;
+type SortOrderParsed = z.output<typeof sortOrderSchema>;
+
+declare const isoDateTimeSchema: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+type IsoDateTimeInput = z.input<typeof isoDateTimeSchema>;
+type IsoDateTimeParsed = z.output<typeof isoDateTimeSchema>;
+
+declare function urlSchema(fieldName: string): z.ZodURL;
+declare function httpsUrlSchema(fieldName: string, maxLength: number): z.ZodURL;
+type UrlInput = z.input<ReturnType<typeof urlSchema>>;
+type UrlParsed = z.output<ReturnType<typeof urlSchema>>;
+type HttpsUrlInput = z.input<ReturnType<typeof httpsUrlSchema>>;
+type HttpsUrlParsed = z.output<ReturnType<typeof httpsUrlSchema>>;
+
+declare const USERNAME_MIN_LENGTH = 1;
+declare const USERNAME_MAX_LENGTH = 100;
+declare const USERNAME_REGEX: RegExp;
+declare const usernameSchema: z.ZodString;
+type UsernameInput = z.input<typeof usernameSchema>;
+type UsernameParsed = z.output<typeof usernameSchema>;
+
+declare const userDetailSchema: z.ZodObject<{
+    id: z.ZodGUID;
+    email: z.ZodString;
+    username: z.ZodNullable<z.ZodString>;
+    authProvider: z.ZodEnum<{
+        email: "email";
+        google: "google";
+    }>;
+    role: z.ZodEnum<{
+        user: "user";
+        moderator: "moderator";
+        admin: "admin";
+    }>;
+    avatarImageId: z.ZodNullable<z.ZodGUID>;
+    avatar: z.ZodNullable<z.ZodObject<{
+        id: z.ZodGUID;
+        hash: z.ZodString;
+        mime: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+        urls: z.ZodObject<{
+            sm: z.ZodURL;
+            md: z.ZodURL;
+            lg: z.ZodURL;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    isCgvAccepted: z.ZodBoolean;
+    cgvAcceptedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+    isMarketingOptedIn: z.ZodBoolean;
+    defaultCurrency: z.ZodEnum<{
+        readonly EUR: "EUR";
+        readonly USD: "USD";
+        readonly GBP: "GBP";
+        readonly CHF: "CHF";
+        readonly CAD: "CAD";
+        readonly AUD: "AUD";
+        readonly JPY: "JPY";
+    }>;
+    emailVerifiedAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+    lastActiveAt: z.ZodNullable<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
+    createdAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+    updatedAt: z.ZodCodec<z.ZodISODateTime, z.ZodDate>;
+}, z.core.$strip>;
+type UserDetailInput = z.input<typeof userDetailSchema>;
+type UserDetailParsed = z.output<typeof userDetailSchema>;
+
+export { CATEGORY_CYCLE_DETECTED_MESSAGE, CATEGORY_MAX_DEPTH_EXCEEDED_MESSAGE, CATEGORY_NOT_FOUND_MESSAGE, COLLAB_ALREADY_MEMBER_MESSAGE, COLLAB_EMAIL_MISMATCH_MESSAGE, COLLAB_INVITE_ALREADY_RESOLVED_MESSAGE, COLLAB_INVITE_EXPIRED_MESSAGE, COLLAB_INVITE_NOT_FOUND_MESSAGE, COLLAB_SELF_INVITE_MESSAGE, DEFAULT_DISPLAY_CURRENCY, DUPLICATE_SHOP_IN_SOURCES_MESSAGE, FEEDBACK_NOT_FOUND_MESSAGE, MAX_CATEGORY_DEPTH, MAX_PASSWORD_LENGTH, MIN_PASSWORD_LENGTH, PAGINATION_DEFAULT_LIMIT, PAGINATION_DEFAULT_PAGE, PAGINATION_MAX_LIMIT, RESERVATION_INCONSISTENT_INTENT_MESSAGE, RESERVATION_REQUIRES_RESERVER_NAME_MESSAGE, RESERVATION_TOKEN_INVALID_MESSAGE, SLUG_GENERATION_EXHAUSTED_MESSAGE, SORT_DIRECTIONS, TAG_INVALID_NAME_MESSAGE, TAG_NOT_FOUND_MESSAGE, USERNAME_MAX_LENGTH, USERNAME_MIN_LENGTH, USERNAME_REGEX, createSlugSchema, displayCurrencyQuerySchema, emailSchema, httpsUrlSchema, imageDetailSchema, imageUrlsSchema, isoDateTimeSchema, messageResponseSchema, noContentResponseSchema, paginatedResponseSchema, paginationMetaSchema, paginationQuerySchema, passwordSchema, sortOrderSchema, sortQuerySchema, supportedCurrencyEnum, urlSchema, userDetailSchema, usernameSchema };
+export type { DisplayCurrencyQueryInput, DisplayCurrencyQueryParsed, EmailInput, EmailParsed, HttpsUrlInput, HttpsUrlParsed, ImageDetailInput, ImageDetailParsed, ImageUrlsInput, ImageUrlsParsed, IsoDateTimeInput, IsoDateTimeParsed, MessageResponseInput, MessageResponseParsed, NoContentResponseInput, NoContentResponseParsed, PaginatedResponse, PaginatedResponseInput, PaginatedResponseParsed, PaginationMetaInput, PaginationMetaParsed, PaginationQueryInput, PaginationQueryParsed, PasswordInput, PasswordParsed, SlugInput, SlugParsed, SlugSchemaOptions, SortDirection, SortInput, SortOrderInput, SortOrderParsed, SortQueryInput, SortQueryParsed, SupportedCurrencyInput, SupportedCurrencyParsed, UrlInput, UrlParsed, UserDetailInput, UserDetailParsed, UsernameInput, UsernameParsed };

package/dist/schemas/index.js

@@ -0,0 +1,73 @@
+export { DEFAULT_DISPLAY_CURRENCY, MAX_PASSWORD_LENGTH, MIN_PASSWORD_LENGTH, USERNAME_MAX_LENGTH, USERNAME_MIN_LENGTH, USERNAME_REGEX, VALIDATION_ROOT_PATH, apiErrorBodySchema, displayCurrencyQuerySchema, emailSchema, forgotPasswordRequestSchema, forgotPasswordResponseSchema, imageDetailSchema, imageUrlsSchema, isoDateTimeSchema, loginRequestSchema, loginResponseSchema, logoutRequestSchema, logoutResponseSchema, messageResponseSchema, passwordSchema, refreshRequestSchema, refreshResponseSchema, registerRequestSchema, registerResponseSchema, resetPasswordRequestSchema, resetPasswordResponseSchema, supportedCurrencyEnum, userDetailSchema, usernameSchema, validationErrorMetadataSchema, validationIssueSchema, verifyEmailRequestSchema, verifyEmailResponseSchema } from '../chunk-VT6MXJE5.js';
+import '../chunk-2LLUUBMQ.js';
+import { z } from 'zod';
+
+// src/schemas/_shared/messages.ts
+var DUPLICATE_SHOP_IN_SOURCES_MESSAGE = "This shop is already used by another source of this item.";
+var SLUG_GENERATION_EXHAUSTED_MESSAGE = "Could not generate a unique slug, please retry with a different title.";
+var MAX_CATEGORY_DEPTH = 3;
+var CATEGORY_NOT_FOUND_MESSAGE = "Category not found";
+var CATEGORY_MAX_DEPTH_EXCEEDED_MESSAGE = `Category depth cannot exceed ${String(MAX_CATEGORY_DEPTH)} levels`;
+var CATEGORY_CYCLE_DETECTED_MESSAGE = "Category parent cannot create a cycle in the hierarchy";
+var TAG_NOT_FOUND_MESSAGE = "Tag not found";
+var TAG_INVALID_NAME_MESSAGE = "Tag name must contain at least one letter or digit after normalization";
+var FEEDBACK_NOT_FOUND_MESSAGE = "Feedback not found";
+var COLLAB_SELF_INVITE_MESSAGE = "You cannot invite yourself to collaborate on your own list";
+var COLLAB_ALREADY_MEMBER_MESSAGE = "This list already has an active editor invitation or collaborator";
+var COLLAB_INVITE_NOT_FOUND_MESSAGE = "Invitation not found";
+var COLLAB_INVITE_EXPIRED_MESSAGE = "This invitation has expired";
+var COLLAB_INVITE_ALREADY_RESOLVED_MESSAGE = "This invitation has already been accepted or revoked";
+var COLLAB_EMAIL_MISMATCH_MESSAGE = "This invitation was issued to a different email address";
+var RESERVATION_TOKEN_INVALID_MESSAGE = "The reservation token is invalid for this reservation";
+var RESERVATION_REQUIRES_RESERVER_NAME_MESSAGE = "reserverName is required when reserving without an account";
+var RESERVATION_INCONSISTENT_INTENT_MESSAGE = "Only the list owner may reserve on behalf of someone else (reserverName)";
+var noContentResponseSchema = z.undefined();
+var PAGINATION_DEFAULT_PAGE = 1;
+var PAGINATION_DEFAULT_LIMIT = 20;
+var PAGINATION_MAX_LIMIT = 100;
+var paginationQuerySchema = z.object({
+  page: z.coerce.number().int().min(1).default(PAGINATION_DEFAULT_PAGE),
+  limit: z.coerce.number().int().min(1).max(PAGINATION_MAX_LIMIT).default(PAGINATION_DEFAULT_LIMIT)
+});
+var paginationMetaSchema = z.object({
+  page: z.number().int(),
+  limit: z.number().int(),
+  total: z.number().int(),
+  totalPages: z.number().int()
+});
+function paginatedResponseSchema(itemSchema) {
+  return z.object({
+    items: z.array(itemSchema),
+    pagination: paginationMetaSchema
+  });
+}
+var SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createSlugSchema({ min, max, example }) {
+  return z.string().trim().min(min).max(max).regex(SLUG_REGEX, `slug must be lowercase letters, digits, and dashes (e.g. ${example})`);
+}
+var SORT_DIRECTIONS = ["asc", "desc"];
+var SORT_FORMAT_REGEX = /^[^:]+:[^:]+$/;
+function sortQuerySchema(allowedFields) {
+  return z.string().regex(SORT_FORMAT_REGEX, "sort must be in the format field:direction").transform((value) => {
+    const [field, direction] = value.split(":");
+    return { field, direction };
+  }).pipe(
+    z.object({
+      field: z.enum(allowedFields),
+      direction: z.enum(SORT_DIRECTIONS)
+    })
+  ).optional();
+}
+var MIN_SORT_ORDER = 0;
+var MAX_SORT_ORDER = 32767;
+var sortOrderSchema = z.number().int("sortOrder must be an integer").min(MIN_SORT_ORDER, `sortOrder must be at least ${String(MIN_SORT_ORDER)}`).max(MAX_SORT_ORDER, `sortOrder must be at most ${String(MAX_SORT_ORDER)}`);
+function urlSchema(fieldName) {
+  return z.url(`${fieldName} must be a valid URL`);
+}
+function httpsUrlSchema(fieldName, maxLength) {
+  return urlSchema(fieldName).max(maxLength).refine((value) => value.startsWith("https://"), `${fieldName} must use HTTPS`);
+}
+
+export { CATEGORY_CYCLE_DETECTED_MESSAGE, CATEGORY_MAX_DEPTH_EXCEEDED_MESSAGE, CATEGORY_NOT_FOUND_MESSAGE, COLLAB_ALREADY_MEMBER_MESSAGE, COLLAB_EMAIL_MISMATCH_MESSAGE, COLLAB_INVITE_ALREADY_RESOLVED_MESSAGE, COLLAB_INVITE_EXPIRED_MESSAGE, COLLAB_INVITE_NOT_FOUND_MESSAGE, COLLAB_SELF_INVITE_MESSAGE, DUPLICATE_SHOP_IN_SOURCES_MESSAGE, FEEDBACK_NOT_FOUND_MESSAGE, MAX_CATEGORY_DEPTH, PAGINATION_DEFAULT_LIMIT, PAGINATION_DEFAULT_PAGE, PAGINATION_MAX_LIMIT, RESERVATION_INCONSISTENT_INTENT_MESSAGE, RESERVATION_REQUIRES_RESERVER_NAME_MESSAGE, RESERVATION_TOKEN_INVALID_MESSAGE, SLUG_GENERATION_EXHAUSTED_MESSAGE, SORT_DIRECTIONS, TAG_INVALID_NAME_MESSAGE, TAG_NOT_FOUND_MESSAGE, createSlugSchema, httpsUrlSchema, noContentResponseSchema, paginatedResponseSchema, paginationMetaSchema, paginationQuerySchema, sortOrderSchema, sortQuerySchema, urlSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/_shared/messages.ts","../../src/schemas/_shared/no-content.ts","../../src/schemas/_shared/pagination.ts","../../src/schemas/_shared/slug.ts","../../src/schemas/_shared/sort.ts","../../src/schemas/_shared/sort-order.ts","../../src/schemas/_shared/url.ts"],"names":["z"],"mappings":"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","file":"index.js","sourcesContent":["export const DUPLICATE_SHOP_IN_SOURCES_MESSAGE =\n  'This shop is already used by another source of this item.'\n\nexport const SLUG_GENERATION_EXHAUSTED_MESSAGE =\n  'Could not generate a unique slug, please retry with a different title.'\n\nexport const MAX_CATEGORY_DEPTH = 3\n\nexport const CATEGORY_NOT_FOUND_MESSAGE = 'Category not found'\n\nexport const CATEGORY_MAX_DEPTH_EXCEEDED_MESSAGE = `Category depth cannot exceed ${String(MAX_CATEGORY_DEPTH)} levels`\n\nexport const CATEGORY_CYCLE_DETECTED_MESSAGE =\n  'Category parent cannot create a cycle in the hierarchy'\n\nexport const TAG_NOT_FOUND_MESSAGE = 'Tag not found'\n\nexport const TAG_INVALID_NAME_MESSAGE =\n  'Tag name must contain at least one letter or digit after normalization'\n\nexport const FEEDBACK_NOT_FOUND_MESSAGE = 'Feedback not found'\n\nexport const COLLAB_SELF_INVITE_MESSAGE =\n  'You cannot invite yourself to collaborate on your own list'\n\nexport const COLLAB_ALREADY_MEMBER_MESSAGE =\n  'This list already has an active editor invitation or collaborator'\n\nexport const COLLAB_INVITE_NOT_FOUND_MESSAGE = 'Invitation not found'\n\nexport const COLLAB_INVITE_EXPIRED_MESSAGE = 'This invitation has expired'\n\nexport const COLLAB_INVITE_ALREADY_RESOLVED_MESSAGE =\n  'This invitation has already been accepted or revoked'\n\nexport const COLLAB_EMAIL_MISMATCH_MESSAGE =\n  'This invitation was issued to a different email address'\n\nexport const RESERVATION_TOKEN_INVALID_MESSAGE =\n  'The reservation token is invalid for this reservation'\n\nexport const RESERVATION_REQUIRES_RESERVER_NAME_MESSAGE =\n  'reserverName is required when reserving without an account'\n\nexport const RESERVATION_INCONSISTENT_INTENT_MESSAGE =\n  'Only the list owner may reserve on behalf of someone else (reserverName)'\n","import { z } from 'zod'\n\n// Response schema for 204 No Content endpoints: the client resolves them to `undefined`.\nexport const noContentResponseSchema = z.undefined()\n\nexport type NoContentResponseInput = z.input<typeof noContentResponseSchema>\nexport type NoContentResponseParsed = z.output<typeof noContentResponseSchema>\n","import { z } from 'zod'\n\nexport const PAGINATION_DEFAULT_PAGE = 1\nexport const PAGINATION_DEFAULT_LIMIT = 20\nexport const PAGINATION_MAX_LIMIT = 100\n\nexport const paginationQuerySchema = z.object({\n  page: z.coerce.number().int().min(1).default(PAGINATION_DEFAULT_PAGE),\n  limit: z.coerce.number().int().min(1).max(PAGINATION_MAX_LIMIT).default(PAGINATION_DEFAULT_LIMIT),\n})\n\nexport type PaginationQueryInput = z.input<typeof paginationQuerySchema>\nexport type PaginationQueryParsed = z.output<typeof paginationQuerySchema>\n\nexport const paginationMetaSchema = z.object({\n  page: z.number().int(),\n  limit: z.number().int(),\n  total: z.number().int(),\n  totalPages: z.number().int(),\n})\n\nexport type PaginationMetaInput = z.input<typeof paginationMetaSchema>\nexport type PaginationMetaParsed = z.output<typeof paginationMetaSchema>\n\nexport interface PaginatedResponse<TItem> {\n  items: TItem[]\n  pagination: PaginationMetaParsed\n}\n\ntype PaginatedResponseSchema<TItemSchema extends z.ZodType> = z.ZodObject<{\n  items: z.ZodArray<TItemSchema>\n  pagination: typeof paginationMetaSchema\n}>\n\nexport function paginatedResponseSchema<TItemSchema extends z.ZodType>(\n  itemSchema: TItemSchema,\n): PaginatedResponseSchema<TItemSchema> {\n  return z.object({\n    items: z.array(itemSchema),\n    pagination: paginationMetaSchema,\n  })\n}\n\nexport type PaginatedResponseInput<TItemSchema extends z.ZodType> = z.input<\n  PaginatedResponseSchema<TItemSchema>\n>\nexport type PaginatedResponseParsed<TItemSchema extends z.ZodType> = z.output<\n  PaginatedResponseSchema<TItemSchema>\n>\n","import { z } from 'zod'\n\nconst SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/\n\nexport interface SlugSchemaOptions {\n  min: number\n  max: number\n  example: string\n}\n\nexport function createSlugSchema({ min, max, example }: SlugSchemaOptions): z.ZodString {\n  return z\n    .string()\n    .trim()\n    .min(min)\n    .max(max)\n    .regex(SLUG_REGEX, `slug must be lowercase letters, digits, and dashes (e.g. ${example})`)\n}\n\nexport type SlugInput = z.input<ReturnType<typeof createSlugSchema>>\nexport type SlugParsed = z.output<ReturnType<typeof createSlugSchema>>\n","import { z } from 'zod'\n\nexport const SORT_DIRECTIONS = ['asc', 'desc'] as const\n\nexport type SortDirection = (typeof SORT_DIRECTIONS)[number]\n\nexport interface SortInput<TField extends string> {\n  field: TField\n  direction: SortDirection\n}\n\nconst SORT_FORMAT_REGEX = /^[^:]+:[^:]+$/\n\nexport function sortQuerySchema<TField extends string>(\n  allowedFields: readonly [TField, ...TField[]],\n) {\n  return z\n    .string()\n    .regex(SORT_FORMAT_REGEX, 'sort must be in the format field:direction')\n    .transform((value) => {\n      const [field, direction] = value.split(':') as [string, string]\n      return { field, direction }\n    })\n    .pipe(\n      z.object({\n        field: z.enum(allowedFields),\n        direction: z.enum(SORT_DIRECTIONS),\n      }),\n    )\n    .optional()\n}\n\nexport type SortQueryInput<TField extends string> = z.input<\n  ReturnType<typeof sortQuerySchema<TField>>\n>\nexport type SortQueryParsed<TField extends string> = z.output<\n  ReturnType<typeof sortQuerySchema<TField>>\n>\n","import { z } from 'zod'\n\nconst MIN_SORT_ORDER = 0\nconst MAX_SORT_ORDER = 32767\n\nexport const sortOrderSchema = z\n  .number()\n  .int('sortOrder must be an integer')\n  .min(MIN_SORT_ORDER, `sortOrder must be at least ${String(MIN_SORT_ORDER)}`)\n  .max(MAX_SORT_ORDER, `sortOrder must be at most ${String(MAX_SORT_ORDER)}`)\n\nexport type SortOrderInput = z.input<typeof sortOrderSchema>\nexport type SortOrderParsed = z.output<typeof sortOrderSchema>\n","import { z } from 'zod'\n\nexport function urlSchema(fieldName: string): z.ZodURL {\n  return z.url(`${fieldName} must be a valid URL`)\n}\n\nexport function httpsUrlSchema(fieldName: string, maxLength: number): z.ZodURL {\n  return urlSchema(fieldName)\n    .max(maxLength)\n    .refine((value) => value.startsWith('https://'), `${fieldName} must use HTTPS`)\n}\n\nexport type UrlInput = z.input<ReturnType<typeof urlSchema>>\nexport type UrlParsed = z.output<ReturnType<typeof urlSchema>>\nexport type HttpsUrlInput = z.input<ReturnType<typeof httpsUrlSchema>>\nexport type HttpsUrlParsed = z.output<ReturnType<typeof httpsUrlSchema>>\n"]}