feat(planning): grille hebdomadaire complète avec API et filtres
- Connexion API via proxy Angular (résolution CORS, base path /api) - Import CSS ng-zorro global pour les modales et composants - Filtres Camion/Show câblés sur l'affichage de la grille - Camions affichés via TrucksService (linkés au show du même créneau) - Panneau de détails : spectacles + camions du jour sélectionné - Modale de création de spectacle stylisée avec fond et centrage - Positionnement précis des events à la minute dans leur créneau - Auto-scroll vers l'heure courante au chargement - Ligne "maintenant" sur la colonne du jour actuel - Régénération des services OpenAPI (nouveaux noms de types) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
+17
-99
@@ -15,18 +15,14 @@ export interface ParseContext<T extends errors.$ZodIssueBase = never> {
|
||||
/** @internal */
|
||||
export interface ParseContextInternal<T extends errors.$ZodIssueBase = never> extends ParseContext<T> {
|
||||
readonly async?: boolean | undefined;
|
||||
readonly direction?: "forward" | "backward";
|
||||
readonly skipChecks?: boolean;
|
||||
}
|
||||
export interface ParsePayload<T = unknown> {
|
||||
value: T;
|
||||
issues: errors.$ZodRawIssue[];
|
||||
/** A may to mark a whole payload as aborted. Used in codecs/pipes. */
|
||||
aborted?: boolean;
|
||||
}
|
||||
export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
|
||||
export interface $ZodTypeDef {
|
||||
type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
|
||||
type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "custom";
|
||||
error?: errors.$ZodErrorMap<never> | undefined;
|
||||
checks?: checks.$ZodCheck<never>[];
|
||||
}
|
||||
@@ -58,7 +54,6 @@ export interface _$ZodTypeInternals {
|
||||
* Todo: unions?
|
||||
*/
|
||||
values?: util.PrimitiveSet | undefined;
|
||||
/** Default value bubbled up from */
|
||||
/** @internal A set of literal discriminators used for the fast path in discriminated unions. */
|
||||
propValues?: util.PropValues | undefined;
|
||||
/** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
|
||||
@@ -153,7 +148,6 @@ export declare const $ZodEmail: core.$constructor<$ZodEmail>;
|
||||
export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
|
||||
hostname?: RegExp | undefined;
|
||||
protocol?: RegExp | undefined;
|
||||
normalize?: boolean | undefined;
|
||||
}
|
||||
export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
|
||||
def: $ZodURLDef;
|
||||
@@ -276,16 +270,6 @@ export interface $ZodIPv6 extends $ZodType {
|
||||
_zod: $ZodIPv6Internals;
|
||||
}
|
||||
export declare const $ZodIPv6: core.$constructor<$ZodIPv6>;
|
||||
export interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
|
||||
delimiter?: string;
|
||||
}
|
||||
export interface $ZodMACInternals extends $ZodStringFormatInternals<"mac"> {
|
||||
def: $ZodMACDef;
|
||||
}
|
||||
export interface $ZodMAC extends $ZodType {
|
||||
_zod: $ZodMACInternals;
|
||||
}
|
||||
export declare const $ZodMAC: core.$constructor<$ZodMAC>;
|
||||
export interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
|
||||
version?: "v4";
|
||||
}
|
||||
@@ -594,15 +578,13 @@ export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $Zod
|
||||
}
|
||||
export interface $ZodObjectInternals<
|
||||
/** @ts-ignore Cast variance */
|
||||
out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
|
||||
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
|
||||
def: $ZodObjectDef<Shape>;
|
||||
config: Config;
|
||||
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
|
||||
propValues: util.PropValues;
|
||||
output: $InferObjectOutput<Shape, Config["out"]>;
|
||||
input: $InferObjectInput<Shape, Config["in"]>;
|
||||
optin?: "optional" | undefined;
|
||||
optout?: "optional" | undefined;
|
||||
}
|
||||
export type $ZodLooseShape = Record<string, any>;
|
||||
export interface $ZodObject<
|
||||
@@ -611,7 +593,6 @@ out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends
|
||||
"~standard": $ZodStandardSchema<this>;
|
||||
}
|
||||
export declare const $ZodObject: core.$constructor<$ZodObject>;
|
||||
export declare const $ZodObjectJIT: core.$constructor<$ZodObject>;
|
||||
export type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;
|
||||
export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;
|
||||
export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
|
||||
@@ -634,16 +615,16 @@ export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]>
|
||||
_zod: $ZodUnionInternals<T>;
|
||||
}
|
||||
export declare const $ZodUnion: core.$constructor<$ZodUnion>;
|
||||
export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
|
||||
discriminator: Disc;
|
||||
export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionDef<Options> {
|
||||
discriminator: string;
|
||||
unionFallback?: boolean;
|
||||
}
|
||||
export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
|
||||
def: $ZodDiscriminatedUnionDef<Options, Disc>;
|
||||
export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<Options> {
|
||||
def: $ZodDiscriminatedUnionDef<Options>;
|
||||
propValues: util.PropValues;
|
||||
}
|
||||
export interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
|
||||
_zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
|
||||
export interface $ZodDiscriminatedUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
|
||||
_zod: $ZodDiscriminatedUnionInternals<T>;
|
||||
}
|
||||
export declare const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion>;
|
||||
export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
|
||||
@@ -651,13 +632,11 @@ export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right ext
|
||||
left: Left;
|
||||
right: Right;
|
||||
}
|
||||
export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
|
||||
export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
|
||||
def: $ZodIntersectionDef<A, B>;
|
||||
isst: never;
|
||||
optin: A["_zod"]["optin"] | B["_zod"]["optin"];
|
||||
optout: A["_zod"]["optout"] | B["_zod"]["optout"];
|
||||
output: core.output<A> & core.output<B>;
|
||||
input: core.input<A> & core.input<B>;
|
||||
}
|
||||
export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
|
||||
_zod: $ZodIntersectionInternals<A, B>;
|
||||
@@ -690,11 +669,9 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
|
||||
...infer Prefix extends SomeType[],
|
||||
infer Tail extends SomeType
|
||||
] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
|
||||
export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
|
||||
export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
|
||||
def: $ZodTupleDef<T, Rest>;
|
||||
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
|
||||
output: $InferTupleOutputType<T, Rest>;
|
||||
input: $InferTupleInputType<T, Rest>;
|
||||
}
|
||||
export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
|
||||
_zod: $ZodTupleInternals<T, Rest>;
|
||||
@@ -784,13 +761,9 @@ export interface $ZodLiteral<T extends util.Literal = util.Literal> extends $Zod
|
||||
_zod: $ZodLiteralInternals<T>;
|
||||
}
|
||||
export declare const $ZodLiteral: core.$constructor<$ZodLiteral>;
|
||||
type _File = typeof globalThis extends {
|
||||
File: infer F extends new (...args: any[]) => any;
|
||||
} ? InstanceType<F> : {};
|
||||
/** Do not reference this directly. */
|
||||
export interface File extends _File {
|
||||
readonly type: string;
|
||||
readonly size: number;
|
||||
declare global {
|
||||
interface File {
|
||||
}
|
||||
}
|
||||
export interface $ZodFileDef extends $ZodTypeDef {
|
||||
type: "file";
|
||||
@@ -928,7 +901,7 @@ export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef
|
||||
innerType: T;
|
||||
catchValue: (ctx: $ZodCatchCtx) => unknown;
|
||||
}
|
||||
export interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {
|
||||
export interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | util.Whatever> {
|
||||
def: $ZodCatchDef<T>;
|
||||
optin: T["_zod"]["optin"];
|
||||
optout: T["_zod"]["optout"];
|
||||
@@ -954,10 +927,6 @@ export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType =
|
||||
type: "pipe";
|
||||
in: A;
|
||||
out: B;
|
||||
/** Only defined inside $ZodCodec instances. */
|
||||
transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
|
||||
/** Only defined inside $ZodCodec instances. */
|
||||
reverseTransform?: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
|
||||
}
|
||||
export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
|
||||
def: $ZodPipeDef<A, B>;
|
||||
@@ -965,28 +934,11 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
|
||||
values: A["_zod"]["values"];
|
||||
optin: A["_zod"]["optin"];
|
||||
optout: B["_zod"]["optout"];
|
||||
propValues: A["_zod"]["propValues"];
|
||||
}
|
||||
export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
|
||||
_zod: $ZodPipeInternals<A, B>;
|
||||
}
|
||||
export declare const $ZodPipe: core.$constructor<$ZodPipe>;
|
||||
export interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {
|
||||
transform: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
|
||||
reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
|
||||
}
|
||||
export interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
|
||||
def: $ZodCodecDef<A, B>;
|
||||
isst: never;
|
||||
values: A["_zod"]["values"];
|
||||
optin: A["_zod"]["optin"];
|
||||
optout: B["_zod"]["optout"];
|
||||
propValues: A["_zod"]["propValues"];
|
||||
}
|
||||
export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
|
||||
_zod: $ZodCodecInternals<A, B>;
|
||||
}
|
||||
export declare const $ZodCodec: core.$constructor<$ZodCodec>;
|
||||
export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
|
||||
type: "readonly";
|
||||
innerType: T;
|
||||
@@ -1006,7 +958,6 @@ export declare const $ZodReadonly: core.$constructor<$ZodReadonly>;
|
||||
export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
|
||||
type: "template_literal";
|
||||
parts: $ZodTemplateLiteralPart[];
|
||||
format?: string | undefined;
|
||||
}
|
||||
export interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
|
||||
pattern: RegExp;
|
||||
@@ -1036,44 +987,11 @@ export type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> =
|
||||
export type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
|
||||
export type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $ZodTemplateLiteralPart] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
|
||||
export declare const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral>;
|
||||
export type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
|
||||
export type $ZodFunctionIn = $ZodFunctionArgs;
|
||||
export type $ZodFunctionOut = $ZodType;
|
||||
export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
|
||||
export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
|
||||
export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
|
||||
export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
|
||||
export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
|
||||
type: "function";
|
||||
input: In;
|
||||
output: Out;
|
||||
}
|
||||
export interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
|
||||
def: $ZodFunctionDef<Args, Returns>;
|
||||
isst: errors.$ZodIssueInvalidType;
|
||||
}
|
||||
export interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
|
||||
/** @deprecated */
|
||||
_def: $ZodFunctionDef<Args, Returns>;
|
||||
_input: $InferInnerFunctionType<Args, Returns>;
|
||||
_output: $InferOuterFunctionType<Args, Returns>;
|
||||
implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
|
||||
implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
|
||||
input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
|
||||
input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
|
||||
input(...args: any[]): $ZodFunction<any, Returns>;
|
||||
output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
|
||||
}
|
||||
export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {
|
||||
input?: I;
|
||||
output?: O;
|
||||
}
|
||||
export declare const $ZodFunction: core.$constructor<$ZodFunction>;
|
||||
export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
|
||||
type: "promise";
|
||||
innerType: T;
|
||||
}
|
||||
export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
|
||||
export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
|
||||
def: $ZodPromiseDef<T>;
|
||||
isst: never;
|
||||
}
|
||||
@@ -1119,5 +1037,5 @@ export interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
|
||||
_zod: $ZodCustomInternals<O, I>;
|
||||
}
|
||||
export declare const $ZodCustom: core.$constructor<$ZodCustom>;
|
||||
export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
|
||||
export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
|
||||
export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
|
||||
export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT;
|
||||
|
||||
Reference in New Issue
Block a user