import { NotNull, PickAny } from "type-fns";
import { Environment } from "sdk-environment";
import { CloudWatchLogsClient, CreateLogGroupCommand, CreateLogStreamCommand, PutLogEventsCommand, ResourceAlreadyExistsException } from "@aws-sdk/client-cloudwatch-logs";
import { Serializable } from "serde-fns";

//#region node_modules/.pnpm/domain-glossary-procedure@1.0.0/node_modules/domain-glossary-procedure/dist/domain/objects/Procedure.d.ts
/**
 * what: the shape of an observable procedure
 *
 * what^2:
 * - observable = easy to read, monitor, and maintain
 * - procedure = an executable of a tactic; tactic.how.procedure::Executable
 *
 * note
 * - javascript's "functions" are actually, by definition, procedures
 */
type Procedure<TInput = any, TContext = any, TOutput = any> = (
/**
 * the input of the procedure
 */
input: TInput,
/**
 * the context within which the procedure runs
 */
context: TContext) => TOutput;
/**
 * extracts the input::Type of a procedure
 */
type ProcedureInput<T extends Procedure> = Parameters<T>[0];
/**
 * extracts the context::Type of a procedure
 */
type ProcedureContext<T extends Procedure> = Parameters<T>[1];
/**
 * extracts the output::Type of a procedure
 */
type ProcedureOutput<T extends Procedure> = ReturnType<T>;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.objects/constants.d.ts
/**
 * define the supported log levels
 */
declare enum LogLevel {
  ERROR = "error",
  WARN = "warn",
  INFO = "info",
  DEBUG = "debug",
}
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.objects/LogOutlet.d.ts
/**
 * .what = a log event that flows through outlets
 * .why = standardized shape for log data across destinations
 */
interface LogEvent {
  level: LogLevel;
  timestamp: string;
  message: string;
  metadata?: Record<string, unknown>;
  env?: Partial<Environment>;
}
/**
 * .what = an outlet that receives log events
 * .why = enables logs to route to external destinations (e.g., CloudWatch)
 */
interface LogOutlet {
  /**
       * .what = send a log event to this outlet
       * .why = buffers or dispatches the event to the destination
       */
  send: (event: LogEvent) => void;
  /**
       * .what = flush buffered events to the destination
       * .why = ensures all buffered logs are sent before process exit
       */
  flush: () => Promise<void>;
  /**
       * .what = close the outlet and release resources
       * .why = cleans up timers and process listeners to prevent leaks in tests
       * .note = optional - not all outlets require cleanup
       */
  close?: () => void;
}
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.objects/LogMethods.d.ts
/**
 * .what = a log method that outputs a message with optional metadata
 */
type LogMethod = (message: string, metadata?: any) => void;
/**
 * .what = the log methods available for use
 */
interface LogMethods {
  /**
       * `error` level logs are used to indicate a critical and urgent failure that requires immediate resolution
       * - these logs are often associated with someone on-call being notified immediately, regardless of the time or day
       * - when choosing to log something with a log level of "error", you are saying that someone should be woken up in the middle of the night if this occurs
       */
  error: LogMethod;
  /**
       * `warn` level logs are used to indicate that something is going wrong, but can wait to be resolved until a convenient time
       * - these logs are often associated with someone following up on them during business hours
       * - when choosing to log something with a log level of "warn", you are saying that someone should look at this as soon as reasonably possible
       */
  warn: LogMethod;
  /**
       * `info` level logs are used to indicate an interesting event that should be kept track of
       * - these logs are often associated with health metrics, dashboard statistics, or custom log queries for investigations or reporting
       * - when choosing to log something with a log level of "info", you are saying that someone will be interested in this information indefinitely
       */
  info: LogMethod;
  /**
       * `debug` level logs are used to output information that can aid users in tracking down bugs or confirming that things are working as expected
       * - these logs are often associated with common actions that happen within code, that may only be relevant when debugging your applications
       * - when choosing to log something with a log level of "debug", you are saying that someone will only be interested in this information when debugging
       */
  debug: LogMethod;
  /**
       * .what = internal config for log methods
       */
  readonly _: Readonly<{
    level: LogLevel;
  }>;
  /**
       * .what = the environment context baked into these log methods
       * .why = enables withLogTrail to inherit env from outer log
       */
  readonly env?: Partial<Environment>;
}
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.objects/LogTrail.d.ts
/**
 * .what = the procedure invocation trail with external identifier
 */
interface LogTrail {
  /**
       * .what = external identifier for request correlation
       * .why = enables log correlation across a single request
       */
  exid: string | null;
  /**
       * .what = the procedure call stack
       * .why = tracks call depth through withLogTrail wraps
       */
  stack: string[];
}
interface ContextLogTrail {
  /**
       * .what = the log context which can be used; methods, trail, etc
       */
  log: LogMethods & {
    _orig?: LogMethods;
    /**
             * .what = the log trail which has been collected
             */
    trail?: LogTrail;
    /**
             * .what = environment context for log output
             */
    env?: Partial<Environment>;
  };
}
type HasContextLogTrail<T extends Procedure> = ProcedureContext<T> extends ContextLogTrail ? T : never;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/genContextLogTrail.d.ts
/**
 * .what = create a log context with trail and env injection
 * .why = enables request correlation via trail.exid and code version via env.commit
 */
declare const genContextLogTrail: ({
  trail,
  env,
  level
}: {
  /**
       * .what = the trail context for log correlation
       * .why = forces caller to explicitly provide or pass null
       */
  trail: {
    exid: string | null;
    stack: string[];
  } | null;
  /**
       * .what = the environment context
       * .why = forces caller to explicitly provide or pass null
       */
  env: Partial<Environment> | null;
  /**
       * .what = the minimum log level to emit
       * .why = allows filter of logs by level
       */
  level?: {
    minimum?: LogLevel;
  };
}) => ContextLogTrail;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/genLogMethods.d.ts
/**
 * define how to generate the log methods
 * - allows you to specify the minimal log level to use for your application
 * - defaults to recommended levels for the environment
 * - allows you to specify outlets for log events to flow to external destinations
 * - allows you to specify env for environment context (e.g., commit hash)
 */
declare const genLogMethods: ({
  level,
  outlets,
  env
}?: {
  level?: {
    minimum?: LogLevel;
  };
  outlets?: LogOutlet[];
  env?: Partial<Environment> | null;
}) => LogMethods;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/outlets/cloudwatch/asDefaultLogStreamName.d.ts
/**
 * .what = generates a default log stream name for CloudWatch
 * .why = matches Lambda's log stream format: YYYY/MM/DD/[$LATEST]instance-id
 * .note = explicit opt-in: user adds outlet only when automatic forwarder absent
 */
declare const asDefaultLogStreamName: () => string;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/outlets/cloudwatch/asLambdaStyleLogGroupName.d.ts
/**
 * .what = generates a lambda-style log group name
 * .why = CloudWatch log groups follow `/aws/lambda/{service}-{env}` pattern
 *
 * .note = performs I/O when service is not provided:
 *         - reads package.json from cwd for service name
 *         - reads env vars (ENVIRONMENT_ACCESS, ENV_ACCESS, STAGE, NODE_ENV) for env.access
 *         for pure usage, pass both service and env.access explicitly.
 *
 * @param service - service name (default: reads from package.json)
 * @param env.access - environment access level (default: from env vars, fallback 'local')
 */
declare const asLambdaStyleLogGroupName: ({
  service,
  env
}?: {
  service?: string;
  env?: {
    access?: string;
  };
}) => string;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/outlets/cloudwatch/genCloudwatchOutlet.d.ts
/**
 * .what = the AWS CloudWatch Logs SDK module
 * .why = dependency injection removes runtime AWS SDK dependency from sdk-logs
 *
 * .usage
 *   import * as sdkAwsCloudwatch from '@aws-sdk/client-cloudwatch-logs';
 *   genCloudwatchOutlet({ ... }, { cloudwatch: { sdk: sdkAwsCloudwatch } });
 */
type SdkAwsCloudwatch = {
  CloudWatchLogsClient: typeof CloudWatchLogsClient;
  CreateLogGroupCommand: typeof CreateLogGroupCommand;
  CreateLogStreamCommand: typeof CreateLogStreamCommand;
  PutLogEventsCommand: typeof PutLogEventsCommand;
  ResourceAlreadyExistsException: typeof ResourceAlreadyExistsException;
};
/**
 * .what = generates a CloudWatch outlet for log events
 * .why = enables log events to flow to CloudWatch in environments without automatic collection
 *
 * .note = explicit opt-in: add this outlet only when automatic log collection is absent.
 *         AWS Lambda and CloudWatch Agent environments auto-collect console.log output.
 *         in those environments, omit this outlet to avoid duplicate logs.
 *
 * @param input.region - AWS region (required: from option or AWS_REGION/AWS_DEFAULT_REGION env)
 * @param input.logGroup - CloudWatch log group name (default: /aws/lambda/{service}-{env})
 * @param input.logStream - CloudWatch log stream name (default: Lambda-style YYYY/MM/DD/[$LATEST]uuid)
 * @param input.skipLogGroupCreation - skip log group findsert (default: false)
 * @param input.flushInterval - auto-flush interval in ms (default: 5000)
 * @param input.maxBufferSize - buffer size threshold in bytes for force-flush (default: 256000)
 * @param context.cloudwatch.sdk - the @aws-sdk/client-cloudwatch-logs module
 * @param context.cloudwatch.client - optional pre-configured CloudWatchLogsClient
 */
declare const genCloudwatchOutlet: (input: {
  region?: string;
  logGroup?: string;
  logStream?: string;
  skipLogGroupCreation?: boolean;
  flushInterval?: number;
  maxBufferSize?: number;
}, context: {
  cloudwatch: {
    sdk: SdkAwsCloudwatch;
    client?: CloudWatchLogsClient;
  };
}) => LogOutlet;
//#endregion
//#region node_modules/.pnpm/domain-glossaries@1.0.0/node_modules/domain-glossaries/dist/AsOfGlossary.d.ts
/**
 * the shape of a type which is declared as part of a particular glossary
 */
interface OfGlossary<G extends string> {
  /**
       * a metadata identifier for the glossary this domain object is part of
       */
  _dglo: G;
}
/**
 * .what = extends the decorated type to specify which glossary it is a part of
 * .why =
 *   - explicitly declare types as part of a domain-glossary
 *     - for example, assign ""
 *   - ensure that a simple type alias does not get reduced by typescript
 *     - e.g., `type UniDate = string` would get introspected as just `string`
 *     - but., `type UniDate = AsOfGlossary<string, 'uni-date'>` will get introspected as `UniDate`
 */
type AsOfGlossary<T, G extends string,
/**
 * whether the _dglo annotation is required
 *
 * usecase
 * - allows requirement of having gone through an explicit type check before attribute can be assigned
 * - true by default, for pit of success, fail-fast safety
 *
 * example
 * ```ts
 * type TimestampWithReq = OfGlossary<string, 'time'>
 * type TimestampWithout = OfGlossary<string, 'time', false>
 *
 * const isOfTimestamp = (input: string): input is TimestampWithReq => {...};
 *
 * const input = '2024, Nov 1';
 * const attemptOne: TimestampWithReq =  // 🛑 fails as `string is not assignable to TimestampWithReq`
 * if (isOfTimestamp(input)) {
 *   const attemptTwo: TimestampWithReq = input; // ✅ passes as the domain check confirmed it is the correct shape
 * }
 * const attemptThree: TimestampWithoutReq = input; // ✅ passes as there was no requirement to ensure it passed through the domain check
 * ```
 */
R = true> = R extends true ? T & OfGlossary<G> : T & Partial<OfGlossary<G>>;
//#endregion
//#region node_modules/.pnpm/iso-time@1.11.7/node_modules/iso-time/dist/domain.objects/IsoDurationShape.d.ts
/**
 * .what = duration as structured object
 * .why = enables programmatic manipulation of duration components
 * .note = no brand needed; the union type IsoDuration provides the brand
 */
type IsoDurationShape = PickAny<{
  years: number;
  months: number;
  weeks: number;
  days: number;
  hours: number;
  minutes: number;
  seconds: number;
  milliseconds: number;
}>;
//#endregion
//#region node_modules/.pnpm/iso-time@1.11.7/node_modules/iso-time/dist/domain.objects/IsoDurationWords.d.ts
/**
 * .what = iso 8601 duration string format
 * .why = enables concise duration literals with compile-time validation
 * .note = no brand needed; template literal union is specific enough
 */
type IsoDurationWordsOnlyTime = `PT${number}S` | `PT${number}M` | `PT${number}H` | `PT${number}M${number}S` | `PT${number}H${number}S` | `PT${number}H${number}M` | `PT${number}H${number}M${number}S` | `PT${number}.${number}S` | `PT${number}H${number}.${number}S` | `PT${number}M${number}.${number}S` | `PT${number}H${number}M${number}.${number}S`;
type IsoDurationWordsOnlyDate = `P${number}Y` | `P${number}M` | `P${number}W` | `P${number}D` | `P${number}Y${number}M` | `P${number}Y${number}D` | `P${number}M${number}D` | `P${number}Y${number}M${number}D` | `P${number}W${number}D`;
type IsoDurationWordsCombined = `P${number}DT${number}H` | `P${number}DT${number}M` | `P${number}DT${number}S` | `P${number}DT${number}H${number}M` | `P${number}DT${number}H${number}S` | `P${number}DT${number}M${number}S` | `P${number}DT${number}H${number}M${number}S` | `P${number}DT${number}H${number}M${number}.${number}S` | `P${number}Y${number}M${number}DT${number}H${number}M${number}S` | `P${number}Y${number}M${number}DT${number}H${number}M${number}.${number}S` | `P${number}YT${number}H` | `P${number}YT${number}M` | `P${number}YT${number}S` | `P${number}Y${number}MT${number}H${number}M` | `P${number}Y${number}MT${number}H${number}M${number}S`;
type IsoDurationWords = IsoDurationWordsOnlyTime | IsoDurationWordsOnlyDate | IsoDurationWordsCombined;
//#endregion
//#region node_modules/.pnpm/iso-time@1.11.7/node_modules/iso-time/dist/domain.objects/IsoDuration.d.ts
/**
 * .what = duration in either string or object format
 * .why = enables users to choose most convenient format per context
 */
type IsoDuration = AsOfGlossary<IsoDurationWords | IsoDurationShape, 'iso-time.IsoDuration', false>;
//#endregion
//#region node_modules/.pnpm/sdk-logs@0.9.2/node_modules/sdk-logs/dist/domain.operations/withLogTrail.d.ts
/**
 * enables input output logging and tracing for a method
 *
 * todo: - add tracing identifier w/ async-context
 * todo: - hookup visual tracing w/ external lib (vi...lo...)
 * todo: - bundle this with its own logging library which supports scoped logs
 */
declare const withLogTrail: <TInput, TContext extends ContextLogTrail, TOutput>(logic: (input: TInput, context: TContext) => TOutput, {
  name: declaredName,
  log: logOptions,
  duration
}: {
  /**
       * specifies the name of the function, if the function does not have a name assigned already
       */
  name?: string | undefined;
  /**
       * enable redacting parts of the input or output from logging
       */
  log?: {
    /**
             * specifies the level to log the trail with
             *
             * note:
             * - defaults input & output logs to level .debug // todo: debug to .trail
             * - defaults error logs to level .warn
             * - error level is only overridable via the object form (to prevent accidental downgrade of error logs)
             */
    level?: LogLevel | {
      input?: LogLevel | undefined;
      output?: LogLevel | undefined;
      error?: LogLevel | undefined;
    } | undefined;
    /**
             * what of the input to log
             */
    input?: ((input: TInput, context: TContext) => any) | undefined;
    /**
             * what of the output to log
             */
    output?: ((value: Awaited<TOutput>) => any) | undefined;
    /**
             * what of the error to log
             */
    error?: ((error: Error) => any) | undefined;
  } | undefined;
  /**
       * specifies the threshold after which a duration will be included on the output log
       */
  duration?: {
    threshold: IsoDuration;
  } | undefined;
}) => (input: TInput, context: TContext) => TOutput;
//#endregion
//#region src/domain.objects/HasName.d.ts
type HasName<T> = T & {
  name: string;
};
declare const hasName: <T>(input: T) => input is HasName<T>;
declare const getName: <T>(input: HasName<T>) => string;
//#endregion
//#region src/domain.operations/asProcedure.d.ts
/**
 * .what = declares a javascript:function to be a procedure
 *
 * .todo =
 *   - extract name from caller fn by default
 *   - withWrappers by default
 */
declare const asProcedure: <TProcedure extends Procedure>(logic: HasContextLogTrail<TProcedure>) => TProcedure;
//#endregion
//#region src/domain.operations/withExpectOutkey.d.ts
type AsExpectOutkey<R extends Record<string, Serializable | null>> = <K extends keyof R, O extends R[K]>(key: K, operation: 'isPresent') => Promise<Record<K, NotNull<O>>>;
type WithExpectOutkey<TLogic extends (...args: any[]) => Promise<Record<string, any>>> = (...args: Parameters<TLogic>) => ReturnType<TLogic> & {
  expect: AsExpectOutkey<Awaited<ReturnType<TLogic>>>;
};
declare const withExpectOutkey: <I, C, O extends Promise<Record<string, any>>>(procedure: Procedure<I, C, O>) => WithExpectOutkey<Procedure<I, C, O>>;
//#endregion
//#region src/domain.operations/withExpectOutput.d.ts
type ExpectOutputIsPresent<O extends Record<string, any> | null> = (operation: 'isPresent') => Promise<NotNull<O>>;
type ExpectOutput<O extends Record<string, any> | null> = ExpectOutputIsPresent<O>;
type WithExpectOutput<TLogic extends (...args: any[]) => Promise<Record<string, any> | null>> = (...args: Parameters<TLogic>) => ReturnType<TLogic> & {
  expect: ExpectOutput<Awaited<ReturnType<TLogic>>>;
};
declare const withExpectOutput: <O extends Record<string, any> | null, TLogic extends (...args: any[]) => Promise<O>>(logic: TLogic) => WithExpectOutput<TLogic>;
//#endregion
export { ContextLogTrail, HasContextLogTrail, HasName, LogEvent, LogLevel, type LogMethod, type LogMethods, LogOutlet, LogTrail, Procedure, ProcedureContext, ProcedureInput, ProcedureOutput, SdkAwsCloudwatch, WithExpectOutkey, WithExpectOutput, asDefaultLogStreamName, asLambdaStyleLogGroupName, asProcedure, genCloudwatchOutlet, genContextLogTrail, genLogMethods, getName, hasName, withExpectOutkey, withExpectOutput, withLogTrail };