@inploi/flows 0.0.0

package/dist/result-6033e9fc.d.ts

@@ -0,0 +1,749 @@
+/**
+ * Issue reason type.
+ */
+type IssueReason = 'any' | 'array' | 'bigint' | 'blob' | 'boolean' | 'date' | 'function' | 'instance' | 'map' | 'number' | 'object' | 'record' | 'set' | 'special' | 'string' | 'symbol' | 'tuple' | 'undefined' | 'unknown' | 'type';
+/**
+ * Issue origin type.
+ */
+type IssueOrigin = 'key' | 'value';
+/**
+ * Path item type.
+ */
+type PathItem = ObjectPathItem | RecordPathItem | TuplePathItem | MapPathItem | SetPathItem | ArrayPathItem;
+/**
+ * Issue type.
+ */
+type Issue = {
+    /**
+     * The issue reason.
+     */
+    reason: IssueReason;
+    /**
+     * The validation name.
+     */
+    validation: string;
+    /**
+     * The issue origin.
+     */
+    origin: IssueOrigin;
+    /**
+     * The error message.
+     */
+    message: string;
+    /**
+     * The input data.
+     */
+    input: unknown;
+    /**
+     * The validation requirement
+     */
+    requirement?: unknown;
+    /**
+     * The issue path.
+     */
+    path?: PathItem[];
+    /**
+     * The sub issues.
+     */
+    issues?: Issues;
+    /**
+     * Whether it was abort early.
+     */
+    abortEarly?: boolean;
+    /**
+     * Whether the pipe was abort early.
+     */
+    abortPipeEarly?: boolean;
+    /**
+     * Whether the pipe was skipped.
+     */
+    skipPipe?: boolean;
+};
+/**
+ * Issues type.
+ */
+type Issues = [Issue, ...Issue[]];
+
+/**
+ * Error message type.
+ */
+type ErrorMessage = string | (() => string);
+/**
+ * Resolve type.
+ *
+ * Hint: This type has no effect and is only used so that TypeScript displays
+ * the final type in the preview instead of the utility types used.
+ */
+type Resolve<T> = T;
+/**
+ * Resolve object type.
+ *
+ * Hint: This type has no effect and is only used so that TypeScript displays
+ * the final type in the preview instead of the utility types used.
+ */
+type ResolveObject<T> = Resolve<{
+    [k in keyof T]: T[k];
+}>;
+
+/**
+ * Parse info type.
+ */
+type ParseInfo = Partial<Pick<Issue, 'origin' | 'abortEarly' | 'abortPipeEarly' | 'skipPipe'>>;
+/**
+ * Parse result type.
+ */
+type _ParseResult<TOutput> = {
+    /**
+     * The parse output.
+     */
+    output: TOutput;
+    /**
+     * The parse issues.
+     */
+    issues?: undefined;
+} | {
+    /**
+     * The parse output.
+     */
+    output?: undefined;
+    /**
+     * The parse issues.
+     */
+    issues: Issues;
+};
+/**
+ * Base schema type.
+ */
+type BaseSchema<TInput = any, TOutput = TInput> = {
+    /**
+     * Whether it's async.
+     */
+    async: false;
+    /**
+     * Parses unknown input based on its schema.
+     *
+     * @param input The input to be parsed.
+     * @param info The parse info.
+     *
+     * @returns The parse result.
+     *
+     * @internal
+     */
+    _parse(input: unknown, info?: ParseInfo): _ParseResult<TOutput>;
+    /**
+     * Input and output type.
+     *
+     * @internal
+     */
+    _types?: {
+        input: TInput;
+        output: TOutput;
+    };
+};
+/**
+ * Base schema async type.
+ */
+type BaseSchemaAsync<TInput = any, TOutput = TInput> = {
+    /**
+     * Whether it's async.
+     */
+    async: true;
+    /**
+     * Parses unknown input based on its schema.
+     *
+     * @param input The input to be parsed.
+     * @param info The parse info.
+     *
+     * @returns The parse result.
+     *
+     * @internal
+     */
+    _parse(input: unknown, info?: ParseInfo): Promise<_ParseResult<TOutput>>;
+    /**
+     * Input and output type.
+     *
+     * @internal
+     */
+    _types?: {
+        input: TInput;
+        output: TOutput;
+    };
+};
+/**
+ * Input inference type.
+ */
+type Input<TSchema extends BaseSchema | BaseSchemaAsync> = NonNullable<TSchema['_types']>['input'];
+/**
+ * Output inference type.
+ */
+type Output<TSchema extends BaseSchema | BaseSchemaAsync> = NonNullable<TSchema['_types']>['output'];
+/**
+ * Pipe result type.
+ */
+type PipeResult<TOutput> = {
+    /**
+     * The pipe output.
+     */
+    output: TOutput;
+    /**
+     * The pipe issues.
+     */
+    issues?: undefined;
+} | {
+    /**
+     * The pipe output.
+     */
+    output?: undefined;
+    /**
+     * The pipe issues.
+     */
+    issues: Pick<Issue, 'validation' | 'message' | 'input' | 'requirement'>[];
+};
+/**
+ * Base validation type.
+ */
+type BaseValidation<TInput = any> = {
+    /**
+     * Whether it's async.
+     */
+    async: false;
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+    /**
+     * Parses unknown input based on its requirement.
+     *
+     * @param input The input to be parsed.
+     *
+     * @returns The parse result.
+     *
+     * @internal
+     */
+    _parse(input: TInput): PipeResult<TInput>;
+};
+/**
+ * Base transformation type.
+ */
+type BaseTransformation<TInput = any> = {
+    /**
+     * Whether it's async.
+     */
+    async: false;
+    /**
+     * Parses unknown input based on its requirement.
+     *
+     * @param input The input to be parsed.
+     *
+     * @returns The parse result.
+     *
+     * @internal
+     */
+    _parse(input: TInput): PipeResult<TInput>;
+};
+/**
+ * Pipe type.
+ */
+type Pipe<TInput> = (BaseValidation<TInput> | BaseTransformation<TInput>)[];
+
+/**
+ * Array path item type.
+ */
+type ArrayPathItem = {
+    type: 'array';
+    input: unknown[];
+    key: number;
+    value: unknown;
+};
+
+/**
+ * Boolean schema type.
+ */
+type BooleanSchema<TOutput = boolean> = BaseSchema<boolean, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'boolean';
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+    /**
+     * The validation and transformation pipeline.
+     */
+    pipe: Pipe<boolean> | undefined;
+};
+
+/**
+ * Literal type.
+ */
+type Literal = number | string | boolean | symbol | bigint;
+
+/**
+ * Literal schema type.
+ */
+type LiteralSchema<TLiteral extends Literal, TOutput = TLiteral> = BaseSchema<TLiteral, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'literal';
+    /**
+     * The literal value.
+     */
+    literal: TLiteral;
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+};
+
+/**
+ * Map path item type.
+ */
+type MapPathItem = {
+    type: 'map';
+    input: Map<unknown, unknown>;
+    key: unknown;
+    value: unknown;
+};
+
+/**
+ * Never schema type.
+ */
+type NeverSchema = BaseSchema<never> & {
+    /**
+     * The schema type.
+     */
+    type: 'never';
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+};
+
+/**
+ * Never schema async type.
+ */
+type NeverSchemaAsync = BaseSchemaAsync<never> & {
+    /**
+     * The schema type.
+     */
+    type: 'never';
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+};
+
+/**
+ * Nullable schema type.
+ */
+type NullableSchema<TWrapped extends BaseSchema, TDefault extends Input<TWrapped> | (() => Input<TWrapped> | undefined) | undefined = undefined, TOutput = TDefault extends Input<TWrapped> ? Output<TWrapped> : Output<TWrapped> | null> = BaseSchema<Input<TWrapped> | null, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'nullable';
+    /**
+     * The wrapped schema.
+     */
+    wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    default: TDefault;
+};
+
+/**
+ * Number schema type.
+ */
+type NumberSchema<TOutput = number> = BaseSchema<number, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'number';
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+    /**
+     * The validation and transformation pipeline.
+     */
+    pipe: Pipe<number> | undefined;
+};
+
+/**
+ * Object entries async type.
+ */
+type ObjectEntriesAsync = Record<string, BaseSchema | BaseSchemaAsync>;
+
+/**
+ * Object path item type.
+ */
+type ObjectPathItem = {
+    type: 'object';
+    input: Record<string, unknown>;
+    key: string;
+    value: unknown;
+};
+/**
+ * Required object keys type.
+ */
+type RequiredKeys<TObject extends object> = {
+    [TKey in keyof TObject]: undefined extends TObject[TKey] ? never : TKey;
+}[keyof TObject];
+/**
+ * Optional object keys type.
+ */
+type OptionalKeys<TObject extends object> = {
+    [TKey in keyof TObject]: undefined extends TObject[TKey] ? TKey : never;
+}[keyof TObject];
+/**
+ * Object with question marks type.
+ */
+type WithQuestionMarks<TObject extends object> = Pick<TObject, RequiredKeys<TObject>> & Partial<Pick<TObject, OptionalKeys<TObject>>>;
+/**
+ * Object input inference type.
+ */
+type ObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync, TRest extends BaseSchema | BaseSchemaAsync | undefined> = TRest extends undefined | NeverSchema | NeverSchemaAsync ? ResolveObject<WithQuestionMarks<{
+    [TKey in keyof TEntries]: Input<TEntries[TKey]>;
+}>> : TRest extends BaseSchema | BaseSchemaAsync ? ResolveObject<WithQuestionMarks<{
+    [TKey in keyof TEntries]: Input<TEntries[TKey]>;
+}>> & Record<string, Input<TRest>> : never;
+/**
+ * Object output inference type.
+ */
+type ObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync, TRest extends BaseSchema | BaseSchemaAsync | undefined> = TRest extends undefined | NeverSchema | NeverSchemaAsync ? ResolveObject<WithQuestionMarks<{
+    [TKey in keyof TEntries]: Output<TEntries[TKey]>;
+}>> : TRest extends BaseSchema | BaseSchemaAsync ? ResolveObject<WithQuestionMarks<{
+    [TKey in keyof TEntries]: Output<TEntries[TKey]>;
+}>> & Record<string, Output<TRest>> : never;
+
+/**
+ * Object entries type.
+ */
+type ObjectEntries = Record<string, BaseSchema>;
+/**
+ * Object schema type.
+ */
+type ObjectSchema<TEntries extends ObjectEntries, TRest extends BaseSchema | undefined = undefined, TOutput = ObjectOutput<TEntries, TRest>> = BaseSchema<ObjectInput<TEntries, TRest>, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'object';
+    /**
+     * The object entries schema.
+     */
+    entries: TEntries;
+    /**
+     * The object rest schema.
+     */
+    rest: TRest;
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+    /**
+     * The validation and transformation pipeline.
+     */
+    pipe: Pipe<ObjectOutput<TEntries, TRest>> | undefined;
+};
+
+/**
+ * Optional schema type.
+ */
+type OptionalSchema<TWrapped extends BaseSchema, TDefault extends Input<TWrapped> | (() => Input<TWrapped> | undefined) | undefined = undefined, TOutput = TDefault extends Input<TWrapped> ? Output<TWrapped> : Output<TWrapped> | undefined> = BaseSchema<Input<TWrapped> | undefined, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'optional';
+    /**
+     * The wrapped schema.
+     */
+    wrapped: TWrapped;
+    /**
+     * Returns the default value.
+     */
+    default: TDefault;
+};
+
+/**
+ * String schema type.
+ */
+type StringSchema<TOutput = string> = BaseSchema<string, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'string';
+    /**
+     * The error message.
+     */
+    message: ErrorMessage;
+    /**
+     * The validation and transformation pipeline.
+     */
+    pipe: Pipe<string> | undefined;
+};
+
+/**
+ * Record path item type.
+ */
+type RecordPathItem = {
+    type: 'record';
+    input: Record<string | number | symbol, unknown>;
+    key: string | number | symbol;
+    value: unknown;
+};
+
+/**
+ * Set path item type.
+ */
+type SetPathItem = {
+    type: 'set';
+    input: Set<unknown>;
+    key: number;
+    value: unknown;
+};
+
+/**
+ * Tuple path item type.
+ */
+type TuplePathItem = {
+    type: 'tuple';
+    input: [unknown, ...unknown[]];
+    key: number;
+    value: unknown;
+};
+
+/**
+ * Unknown schema type.
+ */
+type UnknownSchema<TOutput = unknown> = BaseSchema<unknown, TOutput> & {
+    /**
+     * The schema type.
+     */
+    type: 'unknown';
+    /**
+     * The validation and transformation pipeline.
+     */
+    pipe: Pipe<unknown> | undefined;
+};
+
+declare const responseSchema: ObjectSchema<{
+    /** Not necessarily true when we receive a positive response because the API considers only 200 as success */
+    success: BooleanSchema<boolean>;
+    integration_response: ObjectSchema<{
+        service: OptionalSchema<StringSchema<string>, undefined, string | undefined>;
+        status: NumberSchema<number>;
+        data: UnknownSchema<unknown>;
+        error: NullableSchema<ObjectSchema<{
+            message: StringSchema<string>;
+            data: UnknownSchema<unknown>;
+        }, undefined, {
+            message: string;
+            data?: unknown;
+        }>, undefined, {
+            message: string;
+            data?: unknown;
+        } | null>;
+    }, undefined, {
+        error: {
+            message: string;
+            data?: unknown;
+        } | null;
+        status: number;
+        service?: string | undefined;
+        data?: unknown;
+    }>;
+}, undefined, {
+    success: boolean;
+    integration_response: {
+        error: {
+            message: string;
+            data?: unknown;
+        } | null;
+        status: number;
+        service?: string | undefined;
+        data?: unknown;
+    };
+}>;
+type IntegrationResponse = Output<typeof responseSchema>;
+
+type TextInput = {
+    type: 'text';
+    config: {
+        key: string;
+        optional: boolean;
+        placeholder?: string;
+        format: 'text' | 'email' | 'url' | 'phone';
+        defaultValue?: string;
+        maxChars: number | undefined;
+        minChars: number | undefined;
+    };
+    submission: TextInputSubmission;
+};
+type TextInputSubmission = {
+    type: 'string';
+    value: string;
+};
+type NumberInput = {
+    type: 'number';
+    config: {
+        key: string;
+        optional: boolean;
+        placeholder?: string;
+        defaultValue?: string;
+        decimalCases?: number;
+        min?: number;
+        max?: number;
+    };
+    submission: NumberInputSubmission;
+};
+type NumberInputSubmission = {
+    type: 'number';
+    value: number;
+};
+type MultipleChoiceInput = {
+    type: 'multiple-choice';
+    config: {
+        key: string;
+        options: {
+            value: string;
+            label: string;
+        }[];
+        minSelected?: number;
+        maxSelected?: number;
+    };
+    submission: MultipleChoiceInputSubmission;
+};
+type MultipleChoiceInputSubmission = {
+    type: 'enum';
+    value: string[];
+};
+type BooleanChoiceInput = {
+    type: 'boolean';
+    config: {
+        key: string;
+        labels: {
+            true: string;
+            false: string;
+        };
+        optional: boolean;
+    };
+    submission: BooleanChoiceInputSubmission;
+};
+type BooleanChoiceInputSubmission = {
+    type: 'boolean';
+    value: boolean;
+};
+type FileToUpload = {
+    name: string;
+    data: string;
+    sizeKb: number;
+};
+type FileInput = {
+    type: 'file';
+    config: {
+        key: string;
+        optional: boolean;
+        extensions: string[];
+        fileSizeLimitKib?: number;
+        allowMultiple: boolean;
+    };
+    key: string;
+    submission: FileInputSubmission;
+};
+type FileInputSubmission = {
+    type: 'file';
+    value: FileToUpload[];
+};
+type SubmitInput = {
+    type: 'submit';
+    config: {
+        key: string;
+        label: string;
+    };
+    submission: SubmitInputSubmission;
+};
+type SubmitInputSubmission = {
+    type: 'integration';
+    value: IntegrationResponse;
+};
+type AddressInput = {
+    type: 'address';
+    config: {
+        key: string;
+        optional: boolean;
+        /** Keys for remapping
+         * @example {line1: "lineOne"} will send submissions with the key being "lineOne" instead of "line1"
+         */
+        keys: {
+            line1: string | null;
+            line2: string | null;
+            line3: string | null;
+            city: string | null;
+            state: string | null;
+            postcode: string | null;
+            country: string | null;
+        };
+        placeholder?: string;
+    };
+    submission: AddressInputSubmission;
+};
+type AddressInputSubmission = {
+    type: 'address';
+    value: {
+        [remappedKey: string]: string | undefined;
+    };
+};
+type PhoneInput = {
+    type: 'phone';
+    config: {
+        key: string;
+        optional: boolean;
+        submissionFormat: 'phone' | 'text';
+        placeholder?: string;
+        defaultValue: {
+            countryCode?: string;
+            phoneNumber?: string;
+        };
+        minChars?: number;
+        maxChars?: number;
+    };
+    submission: PhoneInputSubmission;
+};
+type PhoneInputSubmission = {
+    type: 'phone';
+    value: {
+        countryCode: string;
+        phoneNumber: string;
+    };
+} | {
+    type: 'string';
+    value: string;
+};
+type FlowInput = TextInput | NumberInput | MultipleChoiceInput | BooleanChoiceInput | FileInput | SubmitInput | AddressInput | PhoneInput;
+
+type FlowSubmissions = {
+    [key: string]: FlowInput['submission'] | {
+        type: 'integration';
+        value: unknown;
+    };
+};
+
+type Result<R, E> = Ok<R> | Err<E>;
+interface Ok<R> {
+    ok: true;
+    err: false;
+    val: R;
+    '~brand': 'ok';
+}
+declare const Ok: <const R>(val: R) => Ok<R>;
+interface Err<E> {
+    ok: false;
+    err: true;
+    val: E;
+    '~brand': 'err';
+}
+declare const Err: <const E>(val: E) => Err<E>;
+
+export { Err as E, FlowSubmissions as F, Issues as I, LiteralSchema as L, NullableSchema as N, Ok as O, PhoneInput as P, Result as R, StringSchema as S, FlowInput as a, Output as b, ObjectSchema as c, OptionalSchema as d };