tmp.txt

package local:combined-wit;

world combined {
  import spin:postgres/postgres@3.0.0;
  import wasi:config/store@0.2.0-draft-2024-09-27;
  import wasi:io/poll@0.2.0;
  import wasi:clocks/monotonic-clock@0.2.0;
  import wasi:io/error@0.2.0;
  import wasi:io/streams@0.2.0;
  import wasi:http/types@0.2.0;
  import wasi:http/outgoing-handler@0.2.0;
  import fermyon:spin/llm@2.0.0;
  import fermyon:spin/redis@2.0.0;
  import fermyon:spin/rdbms-types@2.0.0;
  import fermyon:spin/postgres@2.0.0;
  import fermyon:spin/mysql@2.0.0;
  import fermyon:spin/mqtt@2.0.0;
  import fermyon:spin/sqlite@2.0.0;
  import fermyon:spin/key-value@2.0.0;
  import fermyon:spin/variables@2.0.0;
  import wasi:keyvalue/store@0.2.0-draft2;
  import wasi:keyvalue/atomics@0.2.0-draft2;
  import wasi:keyvalue/batch@0.2.0-draft2;

  export wasi:http/incoming-handler@0.2.0;
}
package fermyon:spin {
  interface redis-types {
    enum error {
      success,
      error,
    }

    type payload = list<u8>;

    variant redis-parameter {
      int64(s64),
      binary(payload),
    }

    variant redis-result {
      nil,
      status(string),
      int64(s64),
      binary(payload),
    }
  }
  interface inbound-redis {
    use redis-types.{payload, error};

    handle-message: func(message: payload) -> result<_, error>;
  }
}


package wasi:io@0.2.0 {
  interface error {
    resource error {
      to-debug-string: func() -> string;
    }
  }
  interface poll {
    resource pollable {
      ready: func() -> bool;
      block: func();
    }

    poll: func(in: list<borrow<pollable>>) -> list<u32>;
  }
  interface streams {
    use error.{error};
    use poll.{pollable};

    variant stream-error {
      last-operation-failed(error),
      closed,
    }

    resource input-stream {
      read: func(len: u64) -> result<list<u8>, stream-error>;
      blocking-read: func(len: u64) -> result<list<u8>, stream-error>;
      skip: func(len: u64) -> result<u64, stream-error>;
      blocking-skip: func(len: u64) -> result<u64, stream-error>;
      subscribe: func() -> pollable;
    }

    resource output-stream {
      check-write: func() -> result<u64, stream-error>;
      write: func(contents: list<u8>) -> result<_, stream-error>;
      blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>;
      flush: func() -> result<_, stream-error>;
      blocking-flush: func() -> result<_, stream-error>;
      subscribe: func() -> pollable;
      write-zeroes: func(len: u64) -> result<_, stream-error>;
      blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>;
      splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
      blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>;
    }
  }
  world imports {
    import error;
    import poll;
    import streams;
  }
}


package wasi:clocks@0.2.0 {
  interface monotonic-clock {
    use wasi:io/poll@0.2.0.{pollable};

    type instant = u64;

    type duration = u64;

    now: func() -> instant;

    resolution: func() -> duration;

    subscribe-instant: func(when: instant) -> pollable;

    subscribe-duration: func(when: duration) -> pollable;
  }
  interface wall-clock {
    record datetime {
      seconds: u64,
      nanoseconds: u32,
    }

    now: func() -> datetime;

    resolution: func() -> datetime;
  }
  world imports {
    import wasi:io/poll@0.2.0;
    import monotonic-clock;
    import wall-clock;
  }
}


package wasi:random@0.2.0 {
  interface insecure-seed {
    insecure-seed: func() -> tuple<u64, u64>;
  }
  interface insecure {
    get-insecure-random-bytes: func(len: u64) -> list<u8>;

    get-insecure-random-u64: func() -> u64;
  }
  interface random {
    get-random-bytes: func(len: u64) -> list<u8>;

    get-random-u64: func() -> u64;
  }
  world imports {
    import random;
    import insecure;
    import insecure-seed;
  }
}


package wasi:filesystem@0.2.0 {
  interface types {
    use wasi:io/streams@0.2.0.{input-stream, output-stream, error};
    use wasi:clocks/wall-clock@0.2.0.{datetime};

    type filesize = u64;

    enum descriptor-type {
      unknown,
      block-device,
      character-device,
      directory,
      fifo,
      symbolic-link,
      regular-file,
      socket,
    }

    flags descriptor-flags {
      read,
      write,
      file-integrity-sync,
      data-integrity-sync,
      requested-write-sync,
      mutate-directory,
    }

    flags path-flags {
      symlink-follow,
    }

    flags open-flags {
      create,
      directory,
      exclusive,
      truncate,
    }

    type link-count = u64;

    record descriptor-stat {
      %type: descriptor-type,
      link-count: link-count,
      size: filesize,
      data-access-timestamp: option<datetime>,
      data-modification-timestamp: option<datetime>,
      status-change-timestamp: option<datetime>,
    }

    variant new-timestamp {
      no-change,
      now,
      timestamp(datetime),
    }

    record directory-entry {
      %type: descriptor-type,
      name: string,
    }

    enum error-code {
      access,
      would-block,
      already,
      bad-descriptor,
      busy,
      deadlock,
      quota,
      exist,
      file-too-large,
      illegal-byte-sequence,
      in-progress,
      interrupted,
      invalid,
      io,
      is-directory,
      loop,
      too-many-links,
      message-size,
      name-too-long,
      no-device,
      no-entry,
      no-lock,
      insufficient-memory,
      insufficient-space,
      not-directory,
      not-empty,
      not-recoverable,
      unsupported,
      no-tty,
      no-such-device,
      overflow,
      not-permitted,
      pipe,
      read-only,
      invalid-seek,
      text-file-busy,
      cross-device,
    }

    enum advice {
      normal,
      sequential,
      random,
      will-need,
      dont-need,
      no-reuse,
    }

    record metadata-hash-value {
      lower: u64,
      upper: u64,
    }

    resource descriptor {
      read-via-stream: func(offset: filesize) -> result<input-stream, error-code>;
      write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
      append-via-stream: func() -> result<output-stream, error-code>;
      advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
      sync-data: func() -> result<_, error-code>;
      get-flags: func() -> result<descriptor-flags, error-code>;
      get-type: func() -> result<descriptor-type, error-code>;
      set-size: func(size: filesize) -> result<_, error-code>;
      set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
      read: func(length: filesize, offset: filesize) -> result<tuple<list<u8>, bool>, error-code>;
      write: func(buffer: list<u8>, offset: filesize) -> result<filesize, error-code>;
      read-directory: func() -> result<directory-entry-stream, error-code>;
      sync: func() -> result<_, error-code>;
      create-directory-at: func(path: string) -> result<_, error-code>;
      stat: func() -> result<descriptor-stat, error-code>;
      stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
      set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
      link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
      open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
      readlink-at: func(path: string) -> result<string, error-code>;
      remove-directory-at: func(path: string) -> result<_, error-code>;
      rename-at: func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
      symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>;
      unlink-file-at: func(path: string) -> result<_, error-code>;
      is-same-object: func(other: borrow<descriptor>) -> bool;
      metadata-hash: func() -> result<metadata-hash-value, error-code>;
      metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
    }

    resource directory-entry-stream {
      read-directory-entry: func() -> result<option<directory-entry>, error-code>;
    }

    filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
  }
  interface preopens {
    use types.{descriptor};

    get-directories: func() -> list<tuple<descriptor, string>>;
  }
  world imports {
    import wasi:io/error@0.2.0;
    import wasi:io/poll@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:clocks/wall-clock@0.2.0;
    import types;
    import preopens;
  }
}


package wasi:sockets@0.2.0 {
  interface network {
    resource network;

    enum error-code {
      unknown,
      access-denied,
      not-supported,
      invalid-argument,
      out-of-memory,
      timeout,
      concurrency-conflict,
      not-in-progress,
      would-block,
      invalid-state,
      new-socket-limit,
      address-not-bindable,
      address-in-use,
      remote-unreachable,
      connection-refused,
      connection-reset,
      connection-aborted,
      datagram-too-large,
      name-unresolvable,
      temporary-resolver-failure,
      permanent-resolver-failure,
    }

    enum ip-address-family {
      ipv4,
      ipv6,
    }

    type ipv4-address = tuple<u8, u8, u8, u8>;

    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;

    variant ip-address {
      ipv4(ipv4-address),
      ipv6(ipv6-address),
    }

    record ipv4-socket-address {
      port: u16,
      address: ipv4-address,
    }

    record ipv6-socket-address {
      port: u16,
      flow-info: u32,
      address: ipv6-address,
      scope-id: u32,
    }

    variant ip-socket-address {
      ipv4(ipv4-socket-address),
      ipv6(ipv6-socket-address),
    }
  }
  interface instance-network {
    use network.{network};

    instance-network: func() -> network;
  }
  interface ip-name-lookup {
    use wasi:io/poll@0.2.0.{pollable};
    use network.{network, error-code, ip-address};

    resource resolve-address-stream {
      resolve-next-address: func() -> result<option<ip-address>, error-code>;
      subscribe: func() -> pollable;
    }

    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
  }
  interface tcp {
    use wasi:io/streams@0.2.0.{input-stream, output-stream};
    use wasi:io/poll@0.2.0.{pollable};
    use wasi:clocks/monotonic-clock@0.2.0.{duration};
    use network.{network, error-code, ip-socket-address, ip-address-family};

    enum shutdown-type {
      receive,
      send,
      both,
    }

    resource tcp-socket {
      start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
      finish-bind: func() -> result<_, error-code>;
      start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
      finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
      start-listen: func() -> result<_, error-code>;
      finish-listen: func() -> result<_, error-code>;
      accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>;
      local-address: func() -> result<ip-socket-address, error-code>;
      remote-address: func() -> result<ip-socket-address, error-code>;
      is-listening: func() -> bool;
      address-family: func() -> ip-address-family;
      set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
      keep-alive-enabled: func() -> result<bool, error-code>;
      set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
      keep-alive-idle-time: func() -> result<duration, error-code>;
      set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
      keep-alive-interval: func() -> result<duration, error-code>;
      set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
      keep-alive-count: func() -> result<u32, error-code>;
      set-keep-alive-count: func(value: u32) -> result<_, error-code>;
      hop-limit: func() -> result<u8, error-code>;
      set-hop-limit: func(value: u8) -> result<_, error-code>;
      receive-buffer-size: func() -> result<u64, error-code>;
      set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
      send-buffer-size: func() -> result<u64, error-code>;
      set-send-buffer-size: func(value: u64) -> result<_, error-code>;
      subscribe: func() -> pollable;
      shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>;
    }
  }
  interface tcp-create-socket {
    use network.{network, error-code, ip-address-family};
    use tcp.{tcp-socket};

    create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
  }
  interface udp {
    use wasi:io/poll@0.2.0.{pollable};
    use network.{network, error-code, ip-socket-address, ip-address-family};

    record incoming-datagram {
      data: list<u8>,
      remote-address: ip-socket-address,
    }

    record outgoing-datagram {
      data: list<u8>,
      remote-address: option<ip-socket-address>,
    }

    resource udp-socket {
      start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
      finish-bind: func() -> result<_, error-code>;
      %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream, outgoing-datagram-stream>, error-code>;
      local-address: func() -> result<ip-socket-address, error-code>;
      remote-address: func() -> result<ip-socket-address, error-code>;
      address-family: func() -> ip-address-family;
      unicast-hop-limit: func() -> result<u8, error-code>;
      set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
      receive-buffer-size: func() -> result<u64, error-code>;
      set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
      send-buffer-size: func() -> result<u64, error-code>;
      set-send-buffer-size: func(value: u64) -> result<_, error-code>;
      subscribe: func() -> pollable;
    }

    resource incoming-datagram-stream {
      receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>;
      subscribe: func() -> pollable;
    }

    resource outgoing-datagram-stream {
      check-send: func() -> result<u64, error-code>;
      send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>;
      subscribe: func() -> pollable;
    }
  }
  interface udp-create-socket {
    use network.{network, error-code, ip-address-family};
    use udp.{udp-socket};

    create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>;
  }
  world imports {
    import network;
    import instance-network;
    import wasi:io/poll@0.2.0;
    import udp;
    import udp-create-socket;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import tcp;
    import tcp-create-socket;
    import ip-name-lookup;
  }
}


package wasi:cli@0.2.0 {
  interface environment {
    get-environment: func() -> list<tuple<string, string>>;

    get-arguments: func() -> list<string>;

    initial-cwd: func() -> option<string>;
  }
  interface exit {
    exit: func(status: result);
  }
  interface run {
    run: func() -> result;
  }
  interface stdin {
    use wasi:io/streams@0.2.0.{input-stream};

    get-stdin: func() -> input-stream;
  }
  interface stdout {
    use wasi:io/streams@0.2.0.{output-stream};

    get-stdout: func() -> output-stream;
  }
  interface stderr {
    use wasi:io/streams@0.2.0.{output-stream};

    get-stderr: func() -> output-stream;
  }
  interface terminal-input {
    resource terminal-input;
  }
  interface terminal-output {
    resource terminal-output;
  }
  interface terminal-stdin {
    use terminal-input.{terminal-input};

    get-terminal-stdin: func() -> option<terminal-input>;
  }
  interface terminal-stdout {
    use terminal-output.{terminal-output};

    get-terminal-stdout: func() -> option<terminal-output>;
  }
  interface terminal-stderr {
    use terminal-output.{terminal-output};

    get-terminal-stderr: func() -> option<terminal-output>;
  }
  world imports {
    import environment;
    import exit;
    import wasi:io/error@0.2.0;
    import wasi:io/poll@0.2.0;
    import wasi:io/streams@0.2.0;
    import stdin;
    import stdout;
    import stderr;
    import terminal-input;
    import terminal-output;
    import terminal-stdin;
    import terminal-stdout;
    import terminal-stderr;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:clocks/wall-clock@0.2.0;
    import wasi:filesystem/types@0.2.0;
    import wasi:filesystem/preopens@0.2.0;
    import wasi:sockets/network@0.2.0;
    import wasi:sockets/instance-network@0.2.0;
    import wasi:sockets/udp@0.2.0;
    import wasi:sockets/udp-create-socket@0.2.0;
    import wasi:sockets/tcp@0.2.0;
    import wasi:sockets/tcp-create-socket@0.2.0;
    import wasi:sockets/ip-name-lookup@0.2.0;
    import wasi:random/random@0.2.0;
    import wasi:random/insecure@0.2.0;
    import wasi:random/insecure-seed@0.2.0;
  }
  world command {
    import environment;
    import exit;
    import wasi:io/error@0.2.0;
    import wasi:io/poll@0.2.0;
    import wasi:io/streams@0.2.0;
    import stdin;
    import stdout;
    import stderr;
    import terminal-input;
    import terminal-output;
    import terminal-stdin;
    import terminal-stdout;
    import terminal-stderr;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:clocks/wall-clock@0.2.0;
    import wasi:filesystem/types@0.2.0;
    import wasi:filesystem/preopens@0.2.0;
    import wasi:sockets/network@0.2.0;
    import wasi:sockets/instance-network@0.2.0;
    import wasi:sockets/udp@0.2.0;
    import wasi:sockets/udp-create-socket@0.2.0;
    import wasi:sockets/tcp@0.2.0;
    import wasi:sockets/tcp-create-socket@0.2.0;
    import wasi:sockets/ip-name-lookup@0.2.0;
    import wasi:random/random@0.2.0;
    import wasi:random/insecure@0.2.0;
    import wasi:random/insecure-seed@0.2.0;

    export run;
  }
}


package wasi:http@0.2.0 {
  interface types {
    use wasi:clocks/monotonic-clock@0.2.0.{duration};
    use wasi:io/streams@0.2.0.{input-stream, output-stream};
    use wasi:io/error@0.2.0.{error as io-error};
    use wasi:io/poll@0.2.0.{pollable};

    variant method {
      get,
      head,
      post,
      put,
      delete,
      connect,
      options,
      trace,
      patch,
      other(string),
    }

    variant scheme {
      HTTP,
      HTTPS,
      other(string),
    }

    record DNS-error-payload {
      rcode: option<string>,
      info-code: option<u16>,
    }

    record TLS-alert-received-payload {
      alert-id: option<u8>,
      alert-message: option<string>,
    }

    record field-size-payload {
      field-name: option<string>,
      field-size: option<u32>,
    }

    variant error-code {
      DNS-timeout,
      DNS-error(DNS-error-payload),
      destination-not-found,
      destination-unavailable,
      destination-IP-prohibited,
      destination-IP-unroutable,
      connection-refused,
      connection-terminated,
      connection-timeout,
      connection-read-timeout,
      connection-write-timeout,
      connection-limit-reached,
      TLS-protocol-error,
      TLS-certificate-error,
      TLS-alert-received(TLS-alert-received-payload),
      HTTP-request-denied,
      HTTP-request-length-required,
      HTTP-request-body-size(option<u64>),
      HTTP-request-method-invalid,
      HTTP-request-URI-invalid,
      HTTP-request-URI-too-long,
      HTTP-request-header-section-size(option<u32>),
      HTTP-request-header-size(option<field-size-payload>),
      HTTP-request-trailer-section-size(option<u32>),
      HTTP-request-trailer-size(field-size-payload),
      HTTP-response-incomplete,
      HTTP-response-header-section-size(option<u32>),
      HTTP-response-header-size(field-size-payload),
      HTTP-response-body-size(option<u64>),
      HTTP-response-trailer-section-size(option<u32>),
      HTTP-response-trailer-size(field-size-payload),
      HTTP-response-transfer-coding(option<string>),
      HTTP-response-content-coding(option<string>),
      HTTP-response-timeout,
      HTTP-upgrade-failed,
      HTTP-protocol-error,
      loop-detected,
      configuration-error,
      internal-error(option<string>),
    }

    variant header-error {
      invalid-syntax,
      forbidden,
      immutable,
    }

    type field-key = string;

    type field-value = list<u8>;

    resource fields {
      constructor();
      from-list: static func(entries: list<tuple<field-key, field-value>>) -> result<fields, header-error>;
      get: func(name: field-key) -> list<field-value>;
      has: func(name: field-key) -> bool;
      set: func(name: field-key, value: list<field-value>) -> result<_, header-error>;
      delete: func(name: field-key) -> result<_, header-error>;
      append: func(name: field-key, value: field-value) -> result<_, header-error>;
      entries: func() -> list<tuple<field-key, field-value>>;
      clone: func() -> fields;
    }

    type headers = fields;

    type trailers = fields;

    resource incoming-request {
      method: func() -> method;
      path-with-query: func() -> option<string>;
      scheme: func() -> option<scheme>;
      authority: func() -> option<string>;
      headers: func() -> headers;
      consume: func() -> result<incoming-body>;
    }

    resource outgoing-request {
      constructor(headers: headers);
      body: func() -> result<outgoing-body>;
      method: func() -> method;
      set-method: func(method: method) -> result;
      path-with-query: func() -> option<string>;
      set-path-with-query: func(path-with-query: option<string>) -> result;
      scheme: func() -> option<scheme>;
      set-scheme: func(scheme: option<scheme>) -> result;
      authority: func() -> option<string>;
      set-authority: func(authority: option<string>) -> result;
      headers: func() -> headers;
    }

    resource request-options {
      constructor();
      connect-timeout: func() -> option<duration>;
      set-connect-timeout: func(duration: option<duration>) -> result;
      first-byte-timeout: func() -> option<duration>;
      set-first-byte-timeout: func(duration: option<duration>) -> result;
      between-bytes-timeout: func() -> option<duration>;
      set-between-bytes-timeout: func(duration: option<duration>) -> result;
    }

    resource response-outparam {
      set: static func(param: response-outparam, response: result<outgoing-response, error-code>);
    }

    type status-code = u16;

    resource incoming-response {
      status: func() -> status-code;
      headers: func() -> headers;
      consume: func() -> result<incoming-body>;
    }

    resource incoming-body {
      %stream: func() -> result<input-stream>;
      finish: static func(this: incoming-body) -> future-trailers;
    }

    resource future-trailers {
      subscribe: func() -> pollable;
      get: func() -> option<result<result<option<trailers>, error-code>>>;
    }

    resource outgoing-response {
      constructor(headers: headers);
      status-code: func() -> status-code;
      set-status-code: func(status-code: status-code) -> result;
      headers: func() -> headers;
      body: func() -> result<outgoing-body>;
    }

    resource outgoing-body {
      write: func() -> result<output-stream>;
      finish: static func(this: outgoing-body, trailers: option<trailers>) -> result<_, error-code>;
    }

    resource future-incoming-response {
      subscribe: func() -> pollable;
      get: func() -> option<result<result<incoming-response, error-code>>>;
    }

    http-error-code: func(err: borrow<io-error>) -> option<error-code>;
  }
  interface incoming-handler {
    use types.{incoming-request, response-outparam};

    handle: func(request: incoming-request, response-out: response-outparam);
  }
  interface outgoing-handler {
    use types.{outgoing-request, request-options, future-incoming-response, error-code};

    handle: func(request: outgoing-request, options: option<request-options>) -> result<future-incoming-response, error-code>;
  }
  world proxy {
    import wasi:random/random@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/poll@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:cli/stdout@0.2.0;
    import wasi:cli/stderr@0.2.0;
    import wasi:cli/stdin@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import types;
    import outgoing-handler;
    import wasi:clocks/wall-clock@0.2.0;

    export incoming-handler;
  }
}


package fermyon:spin@2.0.0 {
  interface key-value {
    resource store {
      open: static func(label: string) -> result<store, error>;
      get: func(key: string) -> result<option<list<u8>>, error>;
      set: func(key: string, value: list<u8>) -> result<_, error>;
      delete: func(key: string) -> result<_, error>;
      exists: func(key: string) -> result<bool, error>;
      get-keys: func() -> result<list<string>, error>;
    }

    variant error {
      store-table-full,
      no-such-store,
      access-denied,
      other(string),
    }
  }
  interface llm {
    type inferencing-model = string;

    record inferencing-params {
      max-tokens: u32,
      repeat-penalty: f32,
      repeat-penalty-last-n-token-count: u32,
      temperature: f32,
      top-k: u32,
      top-p: f32,
    }

    variant error {
      model-not-supported,
      runtime-error(string),
      invalid-input(string),
    }

    record inferencing-usage {
      prompt-token-count: u32,
      generated-token-count: u32,
    }

    record inferencing-result {
      text: string,
      usage: inferencing-usage,
    }

    type embedding-model = string;

    record embeddings-usage {
      prompt-token-count: u32,
    }

    record embeddings-result {
      embeddings: list<list<f32>>,
      usage: embeddings-usage,
    }

    infer: func(model: inferencing-model, prompt: string, params: option<inferencing-params>) -> result<inferencing-result, error>;

    generate-embeddings: func(model: embedding-model, text: list<string>) -> result<embeddings-result, error>;
  }
  interface mqtt {
    variant error {
      invalid-address,
      too-many-connections,
      connection-failed(string),
      other(string),
    }

    enum qos {
      at-most-once,
      at-least-once,
      exactly-once,
    }

    resource connection {
      open: static func(address: string, username: string, password: string, keep-alive-interval-in-secs: u64) -> result<connection, error>;
      publish: func(topic: string, payload: payload, qos: qos) -> result<_, error>;
    }

    type payload = list<u8>;
  }
  interface rdbms-types {
    variant error {
      connection-failed(string),
      bad-parameter(string),
      query-failed(string),
      value-conversion-failed(string),
      other(string),
    }

    enum db-data-type {
      boolean,
      int8,
      int16,
      int32,
      int64,
      uint8,
      uint16,
      uint32,
      uint64,
      floating32,
      floating64,
      str,
      binary,
      other,
    }

    variant db-value {
      boolean(bool),
      int8(s8),
      int16(s16),
      int32(s32),
      int64(s64),
      uint8(u8),
      uint16(u16),
      uint32(u32),
      uint64(u64),
      floating32(f32),
      floating64(f64),
      str(string),
      binary(list<u8>),
      db-null,
      unsupported,
    }

    variant parameter-value {
      boolean(bool),
      int8(s8),
      int16(s16),
      int32(s32),
      int64(s64),
      uint8(u8),
      uint16(u16),
      uint32(u32),
      uint64(u64),
      floating32(f32),
      floating64(f64),
      str(string),
      binary(list<u8>),
      db-null,
    }

    record column {
      name: string,
      data-type: db-data-type,
    }

    type row = list<db-value>;

    record row-set {
      columns: list<column>,
      rows: list<row>,
    }
  }
  interface mysql {
    use rdbms-types.{parameter-value, row-set, error};

    resource connection {
      open: static func(address: string) -> result<connection, error>;
      query: func(statement: string, params: list<parameter-value>) -> result<row-set, error>;
      execute: func(statement: string, params: list<parameter-value>) -> result<_, error>;
    }
  }
  interface postgres {
    use rdbms-types.{parameter-value, row-set, error};

    resource connection {
      open: static func(address: string) -> result<connection, error>;
      query: func(statement: string, params: list<parameter-value>) -> result<row-set, error>;
      execute: func(statement: string, params: list<parameter-value>) -> result<u64, error>;
    }
  }
  interface redis {
    variant error {
      invalid-address,
      too-many-connections,
      type-error,
      other(string),
    }

    resource connection {
      open: static func(address: string) -> result<connection, error>;
      publish: func(channel: string, payload: payload) -> result<_, error>;
      get: func(key: string) -> result<option<payload>, error>;
      set: func(key: string, value: payload) -> result<_, error>;
      incr: func(key: string) -> result<s64, error>;
      del: func(keys: list<string>) -> result<u32, error>;
      sadd: func(key: string, values: list<string>) -> result<u32, error>;
      smembers: func(key: string) -> result<list<string>, error>;
      srem: func(key: string, values: list<string>) -> result<u32, error>;
      execute: func(command: string, arguments: list<redis-parameter>) -> result<list<redis-result>, error>;
    }

    type payload = list<u8>;

    variant redis-parameter {
      int64(s64),
      binary(payload),
    }

    variant redis-result {
      nil,
      status(string),
      int64(s64),
      binary(payload),
    }
  }
  interface sqlite {
    resource connection {
      open: static func(database: string) -> result<connection, error>;
      execute: func(statement: string, parameters: list<value>) -> result<query-result, error>;
    }

    variant error {
      no-such-database,
      access-denied,
      invalid-connection,
      database-full,
      io(string),
    }

    variant value {
      integer(s64),
      real(f64),
      text(string),
      blob(list<u8>),
      null,
    }

    record row-result {
      values: list<value>,
    }

    record query-result {
      columns: list<string>,
      rows: list<row-result>,
    }
  }
  interface variables {
    variant error {
      invalid-name(string),
      undefined(string),
      provider(string),
      other(string),
    }

    get: func(name: string) -> result<string, error>;
  }
  world spin-imports {
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import llm;
    import redis;
    import rdbms-types;
    import postgres;
    import mysql;
    import mqtt;
    import sqlite;
    import key-value;
    import variables;
  }
  world spin-redis {
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import llm;
    import redis;
    import rdbms-types;
    import postgres;
    import mysql;
    import mqtt;
    import sqlite;
    import key-value;
    import variables;
    import fermyon:spin/redis-types;

    export fermyon:spin/inbound-redis;
  }
  world spin-http {
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import llm;
    import redis;
    import rdbms-types;
    import postgres;
    import mysql;
    import mqtt;
    import sqlite;
    import key-value;
    import variables;

    export wasi:http/incoming-handler@0.2.0;
  }
  world spin-all {
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import llm;
    import redis;
    import rdbms-types;
    import postgres;
    import mysql;
    import mqtt;
    import sqlite;
    import key-value;
    import variables;
    import fermyon:spin/redis-types;

    export fermyon:spin/inbound-redis;
    export wasi:http/incoming-handler@0.2.0;
  }
}


package spin:postgres@3.0.0 {
  interface postgres {
    variant error {
      connection-failed(string),
      bad-parameter(string),
      query-failed(string),
      value-conversion-failed(string),
      other(string),
    }

    enum db-data-type {
      boolean,
      int8,
      int16,
      int32,
      int64,
      floating32,
      floating64,
      str,
      binary,
      date,
      time,
      datetime,
      timestamp,
      other,
    }

    variant db-value {
      boolean(bool),
      int8(s8),
      int16(s16),
      int32(s32),
      int64(s64),
      floating32(f32),
      floating64(f64),
      str(string),
      binary(list<u8>),
      date(tuple<s32, u8, u8>),
      time(tuple<u8, u8, u8, u32>),
      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>),
      timestamp(s64),
      db-null,
      unsupported,
    }

    variant parameter-value {
      boolean(bool),
      int8(s8),
      int16(s16),
      int32(s32),
      int64(s64),
      floating32(f32),
      floating64(f64),
      str(string),
      binary(list<u8>),
      date(tuple<s32, u8, u8>),
      time(tuple<u8, u8, u8, u32>),
      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>),
      timestamp(s64),
      db-null,
    }

    record column {
      name: string,
      data-type: db-data-type,
    }

    type row = list<db-value>;

    record row-set {
      columns: list<column>,
      rows: list<row>,
    }

    resource connection {
      open: static func(address: string) -> result<connection, error>;
      query: func(statement: string, params: list<parameter-value>) -> result<row-set, error>;
      execute: func(statement: string, params: list<parameter-value>) -> result<u64, error>;
    }
  }
}


package wasi:config@0.2.0-draft-2024-09-27 {
  interface store {
    variant error {
      upstream(string),
      io(string),
    }

    get: func(key: string) -> result<option<string>, error>;

    get-all: func() -> result<list<tuple<string, string>>, error>;
  }
  world imports {
    import store;
  }
}


package wasi:keyvalue@0.2.0-draft2 {
  interface store {
    variant error {
      no-such-store,
      access-denied,
      other(string),
    }

    record key-response {
      keys: list<string>,
      cursor: option<string>,
    }

    resource bucket {
      get: func(key: string) -> result<option<list<u8>>, error>;
      set: func(key: string, value: list<u8>) -> result<_, error>;
      delete: func(key: string) -> result<_, error>;
      exists: func(key: string) -> result<bool, error>;
      list-keys: func(cursor: option<string>) -> result<key-response, error>;
    }

    open: func(identifier: string) -> result<bucket, error>;
  }
  interface atomics {
    use store.{bucket, error};

    resource cas {
      new: static func(bucket: borrow<bucket>, key: string) -> result<cas, error>;
      current: func() -> result<option<list<u8>>, error>;
    }

    variant cas-error {
      store-error(error),
      cas-failed(cas),
    }

    increment: func(bucket: borrow<bucket>, key: string, delta: s64) -> result<s64, error>;

    swap: func(cas: cas, value: list<u8>) -> result<_, cas-error>;
  }
  interface batch {
    use store.{bucket, error};

    get-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<list<tuple<string, option<list<u8>>>>, error>;

    set-many: func(bucket: borrow<bucket>, key-values: list<tuple<string, list<u8>>>) -> result<_, error>;

    delete-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<_, error>;
  }
  interface watcher {
    use store.{bucket};

    on-set: func(bucket: bucket, key: string, value: list<u8>);

    on-delete: func(bucket: bucket, key: string);
  }
  world imports {
    import store;
    import atomics;
    import batch;
  }
  world watch-service {
    import store;
    import atomics;
    import batch;

    export watcher;
  }
}


package fermyon:spin@3.0.0 {
  world spin3-imports {
    import spin:postgres/postgres@3.0.0;
    import wasi:config/store@0.2.0-draft-2024-09-27;
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import fermyon:spin/llm@2.0.0;
    import fermyon:spin/redis@2.0.0;
    import fermyon:spin/rdbms-types@2.0.0;
    import fermyon:spin/postgres@2.0.0;
    import fermyon:spin/mysql@2.0.0;
    import fermyon:spin/mqtt@2.0.0;
    import fermyon:spin/sqlite@2.0.0;
    import fermyon:spin/key-value@2.0.0;
    import fermyon:spin/variables@2.0.0;
    import wasi:keyvalue/store@0.2.0-draft2;
    import wasi:keyvalue/atomics@0.2.0-draft2;
    import wasi:keyvalue/batch@0.2.0-draft2;
  }
  world spin3-redis {
    import spin:postgres/postgres@3.0.0;
    import wasi:config/store@0.2.0-draft-2024-09-27;
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import fermyon:spin/llm@2.0.0;
    import fermyon:spin/redis@2.0.0;
    import fermyon:spin/rdbms-types@2.0.0;
    import fermyon:spin/postgres@2.0.0;
    import fermyon:spin/mysql@2.0.0;
    import fermyon:spin/mqtt@2.0.0;
    import fermyon:spin/sqlite@2.0.0;
    import fermyon:spin/key-value@2.0.0;
    import fermyon:spin/variables@2.0.0;
    import wasi:keyvalue/store@0.2.0-draft2;
    import wasi:keyvalue/atomics@0.2.0-draft2;
    import wasi:keyvalue/batch@0.2.0-draft2;
    import fermyon:spin/redis-types;

    export fermyon:spin/inbound-redis;
  }
  world spin3-http {
    import spin:postgres/postgres@3.0.0;
    import wasi:config/store@0.2.0-draft-2024-09-27;
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import fermyon:spin/llm@2.0.0;
    import fermyon:spin/redis@2.0.0;
    import fermyon:spin/rdbms-types@2.0.0;
    import fermyon:spin/postgres@2.0.0;
    import fermyon:spin/mysql@2.0.0;
    import fermyon:spin/mqtt@2.0.0;
    import fermyon:spin/sqlite@2.0.0;
    import fermyon:spin/key-value@2.0.0;
    import fermyon:spin/variables@2.0.0;
    import wasi:keyvalue/store@0.2.0-draft2;
    import wasi:keyvalue/atomics@0.2.0-draft2;
    import wasi:keyvalue/batch@0.2.0-draft2;

    export wasi:http/incoming-handler@0.2.0;
  }
  world spin3-all {
    import spin:postgres/postgres@3.0.0;
    import wasi:config/store@0.2.0-draft-2024-09-27;
    import wasi:io/poll@0.2.0;
    import wasi:clocks/monotonic-clock@0.2.0;
    import wasi:io/error@0.2.0;
    import wasi:io/streams@0.2.0;
    import wasi:http/types@0.2.0;
    import wasi:http/outgoing-handler@0.2.0;
    import fermyon:spin/llm@2.0.0;
    import fermyon:spin/redis@2.0.0;
    import fermyon:spin/rdbms-types@2.0.0;
    import fermyon:spin/postgres@2.0.0;
    import fermyon:spin/mysql@2.0.0;
    import fermyon:spin/mqtt@2.0.0;
    import fermyon:spin/sqlite@2.0.0;
    import fermyon:spin/key-value@2.0.0;
    import fermyon:spin/variables@2.0.0;
    import wasi:keyvalue/store@0.2.0-draft2;
    import wasi:keyvalue/atomics@0.2.0-draft2;
    import wasi:keyvalue/batch@0.2.0-draft2;
    import fermyon:spin/redis-types;

    export fermyon:spin/inbound-redis;
    export wasi:http/incoming-handler@0.2.0;
  }
}