@softruck/api-contracts 0.1.1-beta.3

package/dist/users/configuration/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './schemas.js';
+export * from './types.js';

package/dist/users/configuration/schemas.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const AlertTypeSchema: z.ZodEnum<{
+    BATTERY_DISCONNECTED: "BATTERY_DISCONNECTED";
+    SPEED_OVER: "SPEED_OVER";
+    PANIC_BUTTON: "PANIC_BUTTON";
+    JAMMING_DETECTED: "JAMMING_DETECTED";
+    GEOFENCE_ENTER: "GEOFENCE_ENTER";
+    GEOFENCE_EXIT: "GEOFENCE_EXIT";
+    TOW_TRIGGER: "TOW_TRIGGER";
+    PARK_WATCHER: "PARK_WATCHER";
+}>;
+export declare const AlertRecipientSchema: z.ZodEnum<{
+    responsibles: "responsibles";
+    admin: "admin";
+}>;
+export declare const SubscriptionPlatformSchema: z.ZodEnum<{
+    FCM: "FCM";
+    APNS: "APNS";
+    WEBHOOK: "WEBHOOK";
+}>;
+export declare const VehicleAlertTypeSchema: z.ZodEnum<{
+    IGN: "IGN";
+    MOV: "MOV";
+    GEO: "GEO";
+    RISK: "RISK";
+}>;
+export declare const AlertConfigItemSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        BATTERY_DISCONNECTED: "BATTERY_DISCONNECTED";
+        SPEED_OVER: "SPEED_OVER";
+        PANIC_BUTTON: "PANIC_BUTTON";
+        JAMMING_DETECTED: "JAMMING_DETECTED";
+        GEOFENCE_ENTER: "GEOFENCE_ENTER";
+        GEOFENCE_EXIT: "GEOFENCE_EXIT";
+        TOW_TRIGGER: "TOW_TRIGGER";
+        PARK_WATCHER: "PARK_WATCHER";
+    }>;
+    enabled: z.ZodBoolean;
+    recipients: z.ZodArray<z.ZodEnum<{
+        responsibles: "responsibles";
+        admin: "admin";
+    }>>;
+}, z.core.$strip>;
+export declare const AlertConfigDataSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            BATTERY_DISCONNECTED: "BATTERY_DISCONNECTED";
+            SPEED_OVER: "SPEED_OVER";
+            PANIC_BUTTON: "PANIC_BUTTON";
+            JAMMING_DETECTED: "JAMMING_DETECTED";
+            GEOFENCE_ENTER: "GEOFENCE_ENTER";
+            GEOFENCE_EXIT: "GEOFENCE_EXIT";
+            TOW_TRIGGER: "TOW_TRIGGER";
+            PARK_WATCHER: "PARK_WATCHER";
+        }>;
+        enabled: z.ZodBoolean;
+        recipients: z.ZodArray<z.ZodEnum<{
+            responsibles: "responsibles";
+            admin: "admin";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CreateSubscriptionPayloadSchema: z.ZodObject<{
+    token: z.ZodString;
+    name: z.ZodString;
+    locale: z.ZodString;
+    timezone: z.ZodString;
+    platform: z.ZodEnum<{
+        FCM: "FCM";
+        APNS: "APNS";
+        WEBHOOK: "WEBHOOK";
+    }>;
+    shortname: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ConfigureAlertsPayloadSchema: z.ZodObject<{
+    dtk: z.ZodString;
+    config: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CreateVehicleSubscriptionPayloadSchema: z.ZodObject<{
+    alert: z.ZodEnum<{
+        IGN: "IGN";
+        MOV: "MOV";
+        GEO: "GEO";
+        RISK: "RISK";
+    }>;
+    geofence_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;

package/dist/users/configuration/schemas.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const AlertTypeSchema = z.enum([
+    'BATTERY_DISCONNECTED',
+    'SPEED_OVER',
+    'PANIC_BUTTON',
+    'JAMMING_DETECTED',
+    'GEOFENCE_ENTER',
+    'GEOFENCE_EXIT',
+    'TOW_TRIGGER',
+    'PARK_WATCHER',
+]);
+export const AlertRecipientSchema = z.enum(['responsibles', 'admin']);
+export const SubscriptionPlatformSchema = z.enum(['FCM', 'APNS', 'WEBHOOK']);
+export const VehicleAlertTypeSchema = z.enum(['IGN', 'MOV', 'GEO', 'RISK']);
+export const AlertConfigItemSchema = z.object({
+    type: AlertTypeSchema,
+    enabled: z.boolean(),
+    recipients: z.array(AlertRecipientSchema),
+});
+export const AlertConfigDataSchema = z.object({
+    data: z.array(AlertConfigItemSchema),
+});
+export const CreateSubscriptionPayloadSchema = z.object({
+    token: z.string().min(1),
+    name: z.string().min(1),
+    locale: z.string().min(1),
+    timezone: z.string().min(1),
+    platform: SubscriptionPlatformSchema,
+    shortname: z.string().min(1),
+    url: z.string().url().optional(),
+});
+export const ConfigureAlertsPayloadSchema = z.object({
+    dtk: z.string().min(1),
+    config: z.array(z.object({
+        type: z.string(),
+        enabled: z.boolean(),
+    })),
+});
+export const CreateVehicleSubscriptionPayloadSchema = z.object({
+    alert: VehicleAlertTypeSchema,
+    geofence_ids: z.array(z.string()).optional(),
+}).refine((data) => data.alert !== 'GEO' || (data.geofence_ids && data.geofence_ids.length > 0), { message: 'geofence_ids required for GEO alert type', path: ['geofence_ids'] });

package/dist/users/configuration/types.d.ts

@@ -0,0 +1,36 @@
+export type AlertType = 'BATTERY_DISCONNECTED' | 'SPEED_OVER' | 'PANIC_BUTTON' | 'JAMMING_DETECTED' | 'GEOFENCE_ENTER' | 'GEOFENCE_EXIT' | 'TOW_TRIGGER' | 'PARK_WATCHER';
+export type AlertRecipient = 'responsibles' | 'admin';
+export type SubscriptionPlatform = 'FCM' | 'APNS' | 'WEBHOOK';
+export type VehicleAlertType = 'IGN' | 'MOV' | 'GEO' | 'RISK';
+export interface AlertConfigItem {
+    type: AlertType;
+    enabled: boolean;
+    recipients: AlertRecipient[];
+}
+export interface AlertConfigData {
+    data: AlertConfigItem[];
+}
+export interface CreateSubscriptionPayload {
+    token: string;
+    name: string;
+    locale: string;
+    timezone: string;
+    platform: SubscriptionPlatform;
+    shortname: string;
+    url?: string;
+}
+export interface RegisterConfigurationSubscriptionPayload {
+    token: string;
+}
+export interface SubscriptionAlertConfig {
+    type: string;
+    enabled: boolean;
+}
+export interface ConfigureAlertsPayload {
+    dtk: string;
+    config: SubscriptionAlertConfig[];
+}
+export interface CreateVehicleSubscriptionPayload {
+    alert: VehicleAlertType;
+    geofence_ids?: string[];
+}

package/dist/users/configuration/types.js

@@ -0,0 +1 @@
+export {};

package/dist/users/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './configuration';
+export * from './schemas';
+export * from './types';

package/dist/users/index.js

@@ -0,0 +1,4 @@
+export * from './api.js';
+export * from './configuration/index.js';
+export * from './schemas.js';
+export * from './types.js';

package/dist/users/schemas/addresses.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const CreateAddressPayloadSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        attributes: z.ZodObject<{
+            type: z.ZodEnum<{
+                HOME: "HOME";
+                WORK: "WORK";
+                OTHER: "OTHER";
+            }>;
+            coords: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            formatted_address: z.ZodString;
+            street: z.ZodOptional<z.ZodString>;
+            city: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            country: z.ZodOptional<z.ZodString>;
+            zip_code: z.ZodOptional<z.ZodString>;
+            street_number: z.ZodOptional<z.ZodString>;
+            complement: z.ZodOptional<z.ZodString>;
+            region_short: z.ZodOptional<z.ZodString>;
+            country_code: z.ZodOptional<z.ZodString>;
+            continent_code: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CreateAddressPayload = z.infer<typeof CreateAddressPayloadSchema>;
+export declare const UpdateAddressPayloadSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        attributes: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<{
+                HOME: "HOME";
+                WORK: "WORK";
+                OTHER: "OTHER";
+            }>>;
+            coords: z.ZodOptional<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            formatted_address: z.ZodString;
+            street: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            city: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            region: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            country: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            zip_code: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            street_number: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            complement: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            region_short: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            country_code: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            continent_code: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type UpdateAddressPayload = z.infer<typeof UpdateAddressPayloadSchema>;
+export declare const UserAddressSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"addresses">>;
+    id: z.ZodString;
+    uuid: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodObject<{
+        type: z.ZodEnum<{
+            HOME: "HOME";
+            WORK: "WORK";
+            OTHER: "OTHER";
+        }>;
+        coords: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            type: z.ZodOptional<z.ZodLiteral<"Point">>;
+            coordinates: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>]>>>;
+        formatted_address: z.ZodNullable<z.ZodString>;
+        street: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        city: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        country: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        zip_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        street_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        complement: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        region_short: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        country_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        continent_code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UserAddress = z.infer<typeof UserAddressSchema>;
+export declare const AddressQueryParamsSchema: z.ZodObject<{
+    count: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"only">]>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodType<"region" | "formatted_address" | "city" | "zip_code", unknown, z.core.$ZodTypeInternals<"region" | "formatted_address" | "city" | "zip_code", unknown>>, z.ZodLiteral<"*">]>>>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodType<"region" | "formatted_address" | "city" | "zip_code", unknown, z.core.$ZodTypeInternals<"region" | "formatted_address" | "city" | "zip_code", unknown>> & z.core.$partial, z.ZodUnion<readonly [z.ZodObject<{
+        operator: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            neq: "neq";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            btw: "btw";
+            nbtw: "nbtw";
+            ilk: "ilk";
+            ew: "ew";
+            sw: "sw";
+            nin: "nin";
+            is: "is";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>, z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            neq: "neq";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            btw: "btw";
+            nbtw: "nbtw";
+            ilk: "ilk";
+            ew: "ew";
+            sw: "sw";
+            nin: "nin";
+            is: "is";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>>]>>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        prop: z.ZodType<"region" | "formatted_address" | "city" | "zip_code", unknown, z.core.$ZodTypeInternals<"region" | "formatted_address" | "city" | "zip_code", unknown>>;
+        order: z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AddressQueryParams = z.infer<typeof AddressQueryParamsSchema>;

package/dist/users/schemas/addresses.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { makeQueryParamsSchema, nullableVarCharOptional, varCharOptional } from '../../core/schemas.js';
+const AddressTypeSchema = z.enum(['HOME', 'WORK', 'OTHER']);
+const AddressCoordsPayloadSchema = z.tuple([z.number().min(-90).max(90), z.number().min(-180).max(180)]);
+const AddressListAttributeKeySchema = z.enum(['formatted_address', 'city', 'region', 'zip_code']);
+const AddressCoordsResponseSchema = z.union([
+    AddressCoordsPayloadSchema,
+    z
+        .object({
+        type: z.literal('Point').optional(),
+        coordinates: AddressCoordsPayloadSchema.optional(),
+    })
+        .strict(),
+    z.object({}).strict(),
+]);
+export const CreateAddressPayloadSchema = z
+    .object({
+    data: z
+        .object({
+        attributes: z
+            .object({
+            type: AddressTypeSchema,
+            coords: AddressCoordsPayloadSchema.optional(),
+            formatted_address: z.string(),
+            street: varCharOptional(),
+            city: varCharOptional(),
+            region: varCharOptional(),
+            country: varCharOptional(),
+            zip_code: varCharOptional(),
+            street_number: varCharOptional(),
+            complement: varCharOptional(),
+            region_short: varCharOptional(),
+            country_code: varCharOptional(),
+            continent_code: varCharOptional(),
+            description: varCharOptional(),
+        })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();
+export const UpdateAddressPayloadSchema = z
+    .object({
+    data: z
+        .object({
+        attributes: z
+            .object({
+            type: AddressTypeSchema.optional(),
+            coords: AddressCoordsPayloadSchema.nullable().optional(),
+            formatted_address: z.string(),
+            street: nullableVarCharOptional(),
+            city: nullableVarCharOptional(),
+            region: nullableVarCharOptional(),
+            country: nullableVarCharOptional(),
+            zip_code: nullableVarCharOptional(),
+            street_number: nullableVarCharOptional(),
+            complement: nullableVarCharOptional(),
+            region_short: nullableVarCharOptional(),
+            country_code: nullableVarCharOptional(),
+            continent_code: nullableVarCharOptional(),
+            description: nullableVarCharOptional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const UserAddressSchema = z.object({
+    type: z.literal('addresses').optional(),
+    id: z.string(),
+    uuid: z.string().optional(),
+    attributes: z.object({
+        type: AddressTypeSchema,
+        coords: AddressCoordsResponseSchema.nullable().optional(),
+        formatted_address: z.string().nullable(),
+        street: z.string().nullable().optional(),
+        city: z.string().nullable().optional(),
+        region: z.string().nullable().optional(),
+        country: z.string().nullable().optional(),
+        zip_code: z.string().nullable().optional(),
+        street_number: z.string().nullable().optional(),
+        complement: z.string().nullable().optional(),
+        region_short: z.string().nullable().optional(),
+        country_code: z.string().nullable().optional(),
+        continent_code: z.string().nullable().optional(),
+        description: z.string().nullable().optional(),
+        model: z.string().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        updated_at: z.string().nullable().optional(),
+        deleted_at: z.string().nullable().optional(),
+    }),
+});
+export const AddressQueryParamsSchema = makeQueryParamsSchema(AddressListAttributeKeySchema);

package/dist/users/schemas/authenticated-user.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const AuthenticatedUserDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    attributes: z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        username: z.ZodNullable<z.ZodString>;
+        locale: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
+        otp: z.ZodBoolean;
+        phone1: z.ZodNullable<z.ZodString>;
+        phone2: z.ZodNullable<z.ZodString>;
+        emergency_contact: z.ZodNullable<z.ZodString>;
+        emergency_phone: z.ZodNullable<z.ZodString>;
+        cpf: z.ZodNullable<z.ZodString>;
+        document_number: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodNullable<z.ZodString>;
+        updated_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    relationships: z.ZodObject<{
+        addresses: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        roles: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            attributes: z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        document: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AuthenticatedUserData = z.infer<typeof AuthenticatedUserDataSchema>;

package/dist/users/schemas/authenticated-user.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { NullableTimestampsAttributesSchema, NullableUserContactAttributesSchema, NullableUserDocumentAttributesSchema, RoleAttributesSchema, } from './common.js';
+export const AuthenticatedUserDataSchema = z.object({
+    id: z.string(),
+    attributes: z
+        .object({
+        name: z.string().nullable(),
+        username: z.string().nullable(),
+        locale: z.string().nullable(),
+        email: z.string().nullable(),
+        otp: z.boolean(),
+    })
+        .extend(NullableUserContactAttributesSchema.shape)
+        .extend(NullableUserDocumentAttributesSchema.shape)
+        .extend(NullableTimestampsAttributesSchema.shape),
+    relationships: z.object({
+        addresses: z.array(z.record(z.string(), z.unknown())),
+        roles: z.array(z.object({ id: z.string(), attributes: RoleAttributesSchema })),
+        document: z.record(z.string(), z.unknown()).nullable(),
+    }),
+});

package/dist/users/schemas/common.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const NullableUserContactAttributesSchema: z.ZodObject<{
+    phone1: z.ZodNullable<z.ZodString>;
+    phone2: z.ZodNullable<z.ZodString>;
+    emergency_contact: z.ZodNullable<z.ZodString>;
+    emergency_phone: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const OptionalUserContactAttributesSchema: z.ZodObject<{
+    phone1: z.ZodOptional<z.ZodString>;
+    phone2: z.ZodOptional<z.ZodString>;
+    emergency_contact: z.ZodOptional<z.ZodString>;
+    emergency_phone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const NullableUserDocumentAttributesSchema: z.ZodObject<{
+    cpf: z.ZodNullable<z.ZodString>;
+    document_number: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const OptionalUserDocumentAttributesSchema: z.ZodObject<{
+    cpf: z.ZodOptional<z.ZodString>;
+    document_number: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const NullableTimestampsAttributesSchema: z.ZodObject<{
+    created_at: z.ZodNullable<z.ZodString>;
+    updated_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const RoleAttributesSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;

package/dist/users/schemas/common.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const NullableUserContactAttributesSchema = z.object({
+    phone1: z.string().nullable(),
+    phone2: z.string().nullable(),
+    emergency_contact: z.string().nullable(),
+    emergency_phone: z.string().nullable(),
+});
+export const OptionalUserContactAttributesSchema = z.object({
+    phone1: z.string().optional(),
+    phone2: z.string().optional(),
+    emergency_contact: z.string().optional(),
+    emergency_phone: z.string().optional(),
+});
+export const NullableUserDocumentAttributesSchema = z.object({
+    cpf: z.string().nullable(),
+    document_number: z.string().nullable(),
+});
+export const OptionalUserDocumentAttributesSchema = z.object({
+    cpf: z.string().optional(),
+    document_number: z.string().optional(),
+});
+export const NullableTimestampsAttributesSchema = z.object({
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+});
+export const RoleAttributesSchema = z.object({ name: z.string() });

package/dist/users/schemas/documents.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const UserDocumentSignedLinkPayloadSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        attributes: z.ZodObject<{
+            file_name: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type UserDocumentSignedLinkPayload = z.infer<typeof UserDocumentSignedLinkPayloadSchema>;
+export declare const UserDocumentSignedLinkResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        signed_link: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type UserDocumentSignedLinkResponse = z.infer<typeof UserDocumentSignedLinkResponseSchema>;
+export declare const ConfirmUserDocumentUploadPayloadSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        attributes: z.ZodObject<{
+            name: z.ZodString;
+            key_name: z.ZodString;
+            file_size: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ConfirmUserDocumentUploadPayload = z.infer<typeof ConfirmUserDocumentUploadPayloadSchema>;
+export declare const UserDocumentSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"documents">>;
+    id: z.ZodString;
+    attributes: z.ZodObject<{
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        key_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        file_size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        mime: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UserDocument = z.infer<typeof UserDocumentSchema>;

package/dist/users/schemas/documents.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { varChar } from '../../core/schemas.js';
+export const UserDocumentSignedLinkPayloadSchema = z
+    .object({
+    data: z
+        .object({
+        attributes: z
+            .object({
+            file_name: z.string(),
+        })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();
+export const UserDocumentSignedLinkResponseSchema = z
+    .object({
+    data: z
+        .object({
+        signed_link: z.string(),
+    })
+        .strict(),
+})
+    .strict();
+export const ConfirmUserDocumentUploadPayloadSchema = z
+    .object({
+    data: z
+        .object({
+        attributes: z
+            .object({
+            name: varChar(),
+            key_name: varChar(),
+            file_size: z.number().int(),
+        })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();
+export const UserDocumentSchema = z.object({
+    type: z.literal('documents').optional(),
+    id: z.string(),
+    attributes: z.object({
+        name: z.string().nullable().optional(),
+        key_name: z.string().nullable().optional(),
+        file_size: z.number().nullable().optional(),
+        mime: z.string().nullable().optional(),
+        folder: z.string().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        updated_at: z.string().nullable().optional(),
+        deleted_at: z.string().nullable().optional(),
+    }),
+});

package/dist/users/schemas/passwords.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const UpdatePasswordPayloadSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        attributes: z.ZodObject<{
+            old_password: z.ZodOptional<z.ZodString>;
+            new_password: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type UpdatePasswordPayload = z.infer<typeof UpdatePasswordPayloadSchema>;

package/dist/users/schemas/passwords.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const UpdatePasswordPayloadSchema = z
+    .object({
+    data: z
+        .object({
+        attributes: z
+            .object({
+            old_password: z.string().max(32).optional(),
+            new_password: z.string().max(32),
+        })
+            .strict(),
+    })
+        .strict(),
+})
+    .strict();